${issue.title}
+
${statusLabel}
${issue.program ? `
${issue.program}` : ''}
${ownerIcon} ${issue.owner === 'clawdbot' ? 'Clawdbot' : (issue.owner === 'robert' ? 'Robert' : 'Marius')}
${dateStr}
@@ -2180,17 +2229,27 @@
const issue = issuesData.issues.find(i => i.id === id);
if (!issue) return;
- issue.status = issue.status === 'done' ? 'todo' : 'done';
+ // Cycle: todo → in-progress → done → todo
+ const statusCycle = { 'todo': 'in-progress', 'in-progress': 'done', 'done': 'todo' };
+ const currentStatus = issue.status || 'todo';
+ issue.status = statusCycle[currentStatus] || 'in-progress';
+
if (issue.status === 'done') {
issue.completed = new Date().toISOString();
} else {
delete issue.completed;
}
+ const statusMessages = {
+ 'in-progress': '🔄 In Progress',
+ 'done': '✅ Done!',
+ 'todo': '📋 Todo'
+ };
+
renderIssues();
updateIssuesCount();
await saveIssues();
- showToast(issue.status === 'done' ? 'Issue finalizat! ✓' : 'Issue redeschis');
+ showToast(statusMessages[issue.status]);
}
// Filters
@@ -2212,6 +2271,7 @@
document.getElementById('issueProgram').value = '';
document.getElementById('issueOwner').value = 'marius';
document.getElementById('issuePriority').value = 'urgent-important';
+ document.getElementById('issueStatus').value = 'todo';
document.getElementById('issueDeadline').value = '';
document.getElementById('issueDeleteBtn').style.display = 'none';
document.getElementById('issueSaveBtn').textContent = 'Adaugă';
@@ -2230,6 +2290,7 @@
document.getElementById('issueProgram').value = issue.program || '';
document.getElementById('issueOwner').value = issue.owner || 'marius';
document.getElementById('issuePriority').value = issue.priority || 'backlog';
+ document.getElementById('issueStatus').value = issue.status || 'todo';
document.getElementById('issueDeadline').value = issue.deadline || '';
document.getElementById('issueDeleteBtn').style.display = 'block';
document.getElementById('issueSaveBtn').textContent = 'Salvează';
@@ -2272,6 +2333,13 @@
issue.program = document.getElementById('issueProgram').value;
issue.owner = document.getElementById('issueOwner').value;
issue.priority = document.getElementById('issuePriority').value;
+ const newStatus = document.getElementById('issueStatus').value;
+ if (newStatus === 'done' && issue.status !== 'done') {
+ issue.completed = new Date().toISOString();
+ } else if (newStatus !== 'done') {
+ delete issue.completed;
+ }
+ issue.status = newStatus;
issue.deadline = document.getElementById('issueDeadline').value || null;
issue.updated = new Date().toISOString();
}
@@ -2285,7 +2353,7 @@
program: document.getElementById('issueProgram').value,
owner: document.getElementById('issueOwner').value,
priority: document.getElementById('issuePriority').value,
- status: 'todo',
+ status: document.getElementById('issueStatus').value || 'todo',
created: new Date().toISOString(),
deadline: document.getElementById('issueDeadline').value || null
};
diff --git a/dashboard/issues.json b/dashboard/issues.json
index b312735..c860c15 100644
--- a/dashboard/issues.json
+++ b/dashboard/issues.json
@@ -1,5 +1,5 @@
{
- "lastUpdated": "2026-02-02T11:25:18.119Z",
+ "lastUpdated": "2026-02-02T22:27:06.452Z",
"programs": [
"ROACONT",
"ROAGEST",
@@ -23,7 +23,8 @@
"priority": "urgent-important",
"status": "todo",
"created": "2026-02-02T11:25:18.115Z",
- "deadline": "2026-02-02"
+ "deadline": "2026-02-02",
+ "updated": "2026-02-02T22:27:06.428Z"
},
{
"id": "ROA-001",
@@ -31,10 +32,11 @@
"description": "RD 49 = în urma inspecției fiscale\nRD 50 = impozit precedent\nFormularul nu recalculează impozitul de 16%\nRD 40 se modifică și la 4.1",
"program": "ROACONT",
"owner": "marius",
- "priority": "urgent-important",
+ "priority": "important",
"status": "todo",
"created": "2026-01-30T15:10:00Z",
- "deadline": null
+ "deadline": "2026-02-06",
+ "updated": "2026-02-02T22:26:59.690Z"
}
]
}
\ No newline at end of file
diff --git a/memory/2026-02-02.md b/memory/2026-02-02.md
index c0a5737..9bf3ce0 100644
--- a/memory/2026-02-02.md
+++ b/memory/2026-02-02.md
@@ -1,52 +1,33 @@
-# 2026-02-02 - Note de sesiune
+# 2 Februarie 2026
## Decizii
+- Marius aprobă TOATE propunerile din raportul de seară ("Da")
+- A0 + A3 executate imediat
+- A1 + A2 (sesiuni TU+EU) de programat luni-joi 15:00-16:00
-### Rapoarte pe EMAIL (nu Discord)
-- Morning-report și evening-report merg acum pe **email** (mmarius28@gmail.com)
-- Format nou cu două secțiuni:
- - **📚 Sinteză** - modele/concepte → fișier separat + link
- - **⚡ Acționabile** - task-uri cu CINE/CE/EFORT/REZULTAT clar
-- 3 răspunsuri predefinite (1/2/3) pentru 80/20
-- Job-uri actualizate: `morning-report`, `evening-report`
+## Executat
+- **A0:** Git commit și push (2 commits: TOOLS.md, KB index, coaching, email tool)
+- **A3:** Integrată întrebarea "Ce poveste despre tine ar trebui să renunți?" în insights pentru coaching dimineață
-### Fix email_send.py
-- Problema: MailChannels + Gmail respingeau emailurile
-- Cauza: Emoji în FROM_NAME + header-e non-RFC
-- Fix:
- - `FROM_NAME = "Echo"` (fără emoji)
- - `Header(subject, 'utf-8')` pentru encoding
- - `formataddr((FROM_NAME, SMTP_USER))` pentru RFC compliance
+## De programat
+- **A1:** Sesiune "Dizolvarea lui Nu Merit" (30 min) - exercițiu Monica Ion
+- **A2:** Sistemul 5 pași pentru frici (15 min) - Zoltan Vereș
-### Reguli sub-agenți (AGENTS.md)
-- Când lansez sub-agent, TREBUIE să-i dau tot contextul: AGENTS.md, SOUL.md, USER.md, memory relevant
-- Sub-agentul rulează izolat, nu are acces automat la fișierele mele
+## Feedback Marius
+1. **Email replies:** Nu primește email-urile de confirmare - de verificat flux
+2. **Insights → Rapoarte:** Raportul de seară a fost prea conservator - 22 insights extrase dar doar 4 propuneri în raport. De ajustat job-ul evening-report să propună mai multe.
-## Fișiere create/modificate
+## Stats azi
+- 23 note YouTube în KB (20 procesate azi - Zoltan Vereș workshop)
+- 22 insights extrase în `memory/kb/insights/2026-02-02.md`
+- Job insights-extract funcționează, dar rapoartele nu folosesc toate
-- `memory/kb/insights/2026-02-02.md` - 22 insights din 20 video-uri
-- `memory/kb/insights/sinteza-2026-02-02.md` - 16 modele/concepte (sinteză)
-- `tools/email_send.py` - fix RFC compliance
-- `AGENTS.md` - reguli sub-agenți
-- `TOOLS.md` - documentație joburi actualizată
+## De făcut
+- [x] Ajustez evening-report și morning-report să propună cu ZI și ORĂ concrete
+- [x] Adăugat listare insights disponibile în rapoarte
+- [ ] Programez A1 și A2 cu Marius
-## Aprobat și executat (răspuns email: DA)
-
-**Executat:**
-- ✅ A0: Git commit + push (54 fișiere)
-- ✅ A4: Template seară "10 lucruri" → memory/kb/projects/templates/template-seara-merit.md
-
-**Programat mâine (job grup-sprijin-pregatire):**
-- A3: Fișă grup sprijin - starea de victimă (tema pregătită din insights)
-
-**Programat miercuri-joi 15-16:**
-- A1: Lista eforturilor pt clienți noi (template + completăm împreună)
-- A2: Template valoare adusă clienți (template + completăm împreună)
-- A5: Sesiune film interior (30 min conversație)
-
-## Învățat
-
-- Email deliverability: MailChannels poate bloca emailuri de la hosting shared
-- Gmail e strict pe RFC 5322 - header-ele trebuie corect formatate
-- Rapoarte pe email > Discord pentru decizii care necesită gândire
-- Format "sinteză + acționabile + răspunsuri predefinite" = 80/20 friendly
+## Lecții învățate
+- **Rapoarte:** TOATE propunerile TU+EU/FAC TU trebuie să aibă zi și oră concrete
+- **Email flow:** Reply #1 imediat (confirmare primire), Reply #2 după execuție (ce s-a făcut)
+- **Insights:** Listează TOATE insight-urile disponibile, nu doar câteva
diff --git a/venv/lib/python3.12/site-packages/pypdf-6.6.2.dist-info/INSTALLER b/venv/lib/python3.12/site-packages/pypdf-6.6.2.dist-info/INSTALLER
new file mode 100644
index 0000000..a1b589e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf-6.6.2.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/venv/lib/python3.12/site-packages/pypdf-6.6.2.dist-info/METADATA b/venv/lib/python3.12/site-packages/pypdf-6.6.2.dist-info/METADATA
new file mode 100644
index 0000000..54058ec
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf-6.6.2.dist-info/METADATA
@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: pypdf
+Version: 6.6.2
+Summary: A pure-python PDF library capable of splitting, merging, cropping, and transforming PDF files
+Author-email: Mathieu Fenniak
+Maintainer: stefan6419846
+Maintainer-email: Martin Thoma
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-Expression: BSD-3-Clause
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+License-File: LICENSE
+Requires-Dist: typing_extensions >= 4.0; python_version < '3.11'
+Requires-Dist: cryptography ; extra == "crypto"
+Requires-Dist: PyCryptodome ; extra == "cryptodome"
+Requires-Dist: black ; extra == "dev"
+Requires-Dist: flit ; extra == "dev"
+Requires-Dist: pip-tools ; extra == "dev"
+Requires-Dist: pre-commit ; extra == "dev"
+Requires-Dist: pytest-cov ; extra == "dev"
+Requires-Dist: pytest-socket ; extra == "dev"
+Requires-Dist: pytest-timeout ; extra == "dev"
+Requires-Dist: pytest-xdist ; extra == "dev"
+Requires-Dist: wheel ; extra == "dev"
+Requires-Dist: myst_parser ; extra == "docs"
+Requires-Dist: sphinx ; extra == "docs"
+Requires-Dist: sphinx_rtd_theme ; extra == "docs"
+Requires-Dist: cryptography ; extra == "full"
+Requires-Dist: Pillow>=8.0.0 ; extra == "full"
+Requires-Dist: Pillow>=8.0.0 ; extra == "image"
+Project-URL: Bug Reports, https://github.com/py-pdf/pypdf/issues
+Project-URL: Changelog, https://pypdf.readthedocs.io/en/latest/meta/CHANGELOG.html
+Project-URL: Documentation, https://pypdf.readthedocs.io/en/latest/
+Project-URL: Source, https://github.com/py-pdf/pypdf
+Provides-Extra: crypto
+Provides-Extra: cryptodome
+Provides-Extra: dev
+Provides-Extra: docs
+Provides-Extra: full
+Provides-Extra: image
+
+[](https://badge.fury.io/py/pypdf)
+[](https://pypi.org/project/pypdf/)
+[](https://pypdf.readthedocs.io/en/stable/)
+[](https://github.com/py-pdf/pypdf)
+[](https://codecov.io/gh/py-pdf/pypdf)
+
+# pypdf
+
+pypdf is a free and open-source pure-python PDF library capable of splitting,
+[merging](https://pypdf.readthedocs.io/en/stable/user/merging-pdfs.html),
+[cropping, and transforming](https://pypdf.readthedocs.io/en/stable/user/cropping-and-transforming.html)
+the pages of PDF files. It can also add
+custom data, viewing options, and
+[passwords](https://pypdf.readthedocs.io/en/stable/user/encryption-decryption.html)
+to PDF files. pypdf can
+[retrieve text](https://pypdf.readthedocs.io/en/stable/user/extract-text.html)
+and
+[metadata](https://pypdf.readthedocs.io/en/stable/user/metadata.html)
+from PDFs as well.
+
+See [pdfly](https://github.com/py-pdf/pdfly) for a CLI application that uses pypdf to interact with PDFs.
+
+## Installation
+
+Install pypdf using pip:
+
+```
+pip install pypdf
+```
+
+For using pypdf with AES encryption or decryption, install extra dependencies:
+
+```
+pip install pypdf[crypto]
+```
+
+> **NOTE**: `pypdf` 3.1.0 and above include significant improvements compared to
+> previous versions. Please refer to [the migration
+> guide](https://pypdf.readthedocs.io/en/latest/user/migration-1-to-2.html) for
+> more information.
+
+## Usage
+
+```python
+from pypdf import PdfReader
+
+reader = PdfReader("example.pdf")
+number_of_pages = len(reader.pages)
+page = reader.pages[0]
+text = page.extract_text()
+```
+
+pypdf can do a lot more, e.g. splitting, merging, reading and creating annotations, decrypting and encrypting. Check out the
+[documentation](https://pypdf.readthedocs.io/en/stable/) for additional usage
+examples!
+
+For questions and answers, visit
+[StackOverflow](https://stackoverflow.com/questions/tagged/pypdf)
+(tagged with [pypdf](https://stackoverflow.com/questions/tagged/pypdf)).
+
+## Contributions
+
+Maintaining pypdf is a collaborative effort. You can support the project by
+writing documentation, helping to narrow down issues, and submitting code.
+See the [CONTRIBUTING.md](https://github.com/py-pdf/pypdf/blob/main/CONTRIBUTING.md) file for more information.
+
+### Q&A
+
+The experience pypdf users have covers the whole range from beginner to expert. You can contribute to the pypdf community by answering questions
+on [StackOverflow](https://stackoverflow.com/questions/tagged/pypdf),
+helping in [discussions](https://github.com/py-pdf/pypdf/discussions),
+and asking users who report issues for [MCVE](https://stackoverflow.com/help/minimal-reproducible-example)'s (Code + example PDF!).
+
+
+### Issues
+
+A good bug ticket includes a MCVE - a minimal complete verifiable example.
+For pypdf, this means that you must upload a PDF that causes the bug to occur
+as well as the code you're executing with all of the output. Use
+`print(pypdf.__version__)` to tell us which version you're using.
+
+### Code
+
+All code contributions are welcome, but smaller ones have a better chance to
+get included in a timely manner. Adding unit tests for new features or test
+cases for bugs you've fixed help us to ensure that the Pull Request (PR) is fine.
+
+pypdf includes a test suite which can be executed with `pytest`:
+
+```bash
+$ pytest
+===================== test session starts =====================
+platform linux -- Python 3.6.15, pytest-7.0.1, pluggy-1.0.0
+rootdir: /home/moose/GitHub/Martin/pypdf
+plugins: cov-3.0.0
+collected 233 items
+
+tests/test_basic_features.py .. [ 0%]
+tests/test_constants.py . [ 1%]
+tests/test_filters.py .................x..... [ 11%]
+tests/test_generic.py ................................. [ 25%]
+............. [ 30%]
+tests/test_javascript.py .. [ 31%]
+tests/test_merger.py . [ 32%]
+tests/test_page.py ......................... [ 42%]
+tests/test_pagerange.py ................ [ 49%]
+tests/test_papersizes.py .................. [ 57%]
+tests/test_reader.py .................................. [ 72%]
+............... [ 78%]
+tests/test_utils.py .................... [ 87%]
+tests/test_workflows.py .......... [ 91%]
+tests/test_writer.py ................. [ 98%]
+tests/test_xmp.py ... [100%]
+
+========== 232 passed, 1 xfailed, 1 warning in 4.52s ==========
+```
+
diff --git a/venv/lib/python3.12/site-packages/pypdf-6.6.2.dist-info/RECORD b/venv/lib/python3.12/site-packages/pypdf-6.6.2.dist-info/RECORD
new file mode 100644
index 0000000..3c67e97
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf-6.6.2.dist-info/RECORD
@@ -0,0 +1,117 @@
+pypdf-6.6.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pypdf-6.6.2.dist-info/METADATA,sha256=1Vu0OgjW3amj2S_YMUmD0Lj_7_GEw-f5VaIM-_9niK8,7149
+pypdf-6.6.2.dist-info/RECORD,,
+pypdf-6.6.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypdf-6.6.2.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+pypdf-6.6.2.dist-info/licenses/LICENSE,sha256=qXrCMOXzPvEKU2eoUOsB-R8aCwZONHQsd5TSKUVX9SQ,1605
+pypdf/__init__.py,sha256=YS_1ZrQ3jBPHsRgMstqJrAts3lUApj_lMOMK5qiLG5w,1283
+pypdf/__pycache__/__init__.cpython-312.pyc,,
+pypdf/__pycache__/_cmap.cpython-312.pyc,,
+pypdf/__pycache__/_doc_common.cpython-312.pyc,,
+pypdf/__pycache__/_encryption.cpython-312.pyc,,
+pypdf/__pycache__/_font.cpython-312.pyc,,
+pypdf/__pycache__/_page.cpython-312.pyc,,
+pypdf/__pycache__/_page_labels.cpython-312.pyc,,
+pypdf/__pycache__/_protocols.cpython-312.pyc,,
+pypdf/__pycache__/_reader.cpython-312.pyc,,
+pypdf/__pycache__/_utils.cpython-312.pyc,,
+pypdf/__pycache__/_version.cpython-312.pyc,,
+pypdf/__pycache__/_writer.cpython-312.pyc,,
+pypdf/__pycache__/_xobj_image_helpers.cpython-312.pyc,,
+pypdf/__pycache__/constants.cpython-312.pyc,,
+pypdf/__pycache__/errors.cpython-312.pyc,,
+pypdf/__pycache__/filters.cpython-312.pyc,,
+pypdf/__pycache__/pagerange.cpython-312.pyc,,
+pypdf/__pycache__/papersizes.cpython-312.pyc,,
+pypdf/__pycache__/types.cpython-312.pyc,,
+pypdf/__pycache__/xmp.cpython-312.pyc,,
+pypdf/_cmap.py,sha256=iaAvJQQKBxkqMj5-WdD4vZV-Zdz-Sba5j6q3oPQyLT0,11713
+pypdf/_codecs/__init__.py,sha256=PF1KlsLWCOF0cgdqns7G4X-l3zq5_OnZePw7RFIn1bE,1645
+pypdf/_codecs/__pycache__/__init__.cpython-312.pyc,,
+pypdf/_codecs/__pycache__/_codecs.cpython-312.pyc,,
+pypdf/_codecs/__pycache__/adobe_glyphs.cpython-312.pyc,,
+pypdf/_codecs/__pycache__/core_fontmetrics.cpython-312.pyc,,
+pypdf/_codecs/__pycache__/pdfdoc.cpython-312.pyc,,
+pypdf/_codecs/__pycache__/std.cpython-312.pyc,,
+pypdf/_codecs/__pycache__/symbol.cpython-312.pyc,,
+pypdf/_codecs/__pycache__/zapfding.cpython-312.pyc,,
+pypdf/_codecs/_codecs.py,sha256=46oRZJySwGxCJp1kjIer7js_TYSjj4Gs2i2Uce3v-eE,10555
+pypdf/_codecs/adobe_glyphs.py,sha256=t3cDFPDqwIz1w9B0gdVzjdc8eEK9AuRjk5f7laEw_fY,447213
+pypdf/_codecs/core_fontmetrics.py,sha256=qQvNRQi8V8FOBmSwGcsak4qyl9cQ80cDjbpD5TvhuBg,113269
+pypdf/_codecs/pdfdoc.py,sha256=xfSvMFYsvxuaSQ0Uu9vZDKaB0Wu85h1uCiB1i9rAcUU,4269
+pypdf/_codecs/std.py,sha256=DyQMuEpAGEpS9uy1jWf4cnj-kqShPOAij5sI7Q1YD8E,2630
+pypdf/_codecs/symbol.py,sha256=nIaGQIlhWCJiPMHrwUlmGHH-_fOXyEKvguRmuKXcGAk,3734
+pypdf/_codecs/zapfding.py,sha256=PQxjxRC616d41xF3exVxP1W8nM4QrZfjO3lmtLxpE_s,3742
+pypdf/_crypt_providers/__init__.py,sha256=K3Z6AuXhXVeXgLet-Tukq2gt9H66OgdupsvxIS1CmkI,3054
+pypdf/_crypt_providers/__pycache__/__init__.cpython-312.pyc,,
+pypdf/_crypt_providers/__pycache__/_base.cpython-312.pyc,,
+pypdf/_crypt_providers/__pycache__/_cryptography.cpython-312.pyc,,
+pypdf/_crypt_providers/__pycache__/_fallback.cpython-312.pyc,,
+pypdf/_crypt_providers/__pycache__/_pycryptodome.cpython-312.pyc,,
+pypdf/_crypt_providers/_base.py,sha256=_f53Mj6vivhEZMQ4vNxN5G0IOgFY-n5_leke0c_qiNU,1711
+pypdf/_crypt_providers/_cryptography.py,sha256=zT3WmbPzesvgHRkGcKAldqJ24MY3BwZViVbSc55Zxhw,4557
+pypdf/_crypt_providers/_fallback.py,sha256=vsYoowR1YCAV_q-HrdIZhkUcrCb6HvRBNMYm03QtCU8,3334
+pypdf/_crypt_providers/_pycryptodome.py,sha256=U1aQZ9iYBrZo-hKCjJUhGOPhwEFToiitowQ316TNrrA,3381
+pypdf/_doc_common.py,sha256=Cbsc2uczFhAi2JRioaICx0ISC4lCBkRdo_tKRGw3bpc,53243
+pypdf/_encryption.py,sha256=-LwFEKfhL3B10afkco6fXx-EqtjoXf67pAUgH2VBfDw,48762
+pypdf/_font.py,sha256=R5jQsBYa_eMrK7VezyoWCmbBARZyS5xp8jzD2XRvKeE,14146
+pypdf/_page.py,sha256=Tp2GyjjOHLFwQ1tw8bO-poyZA65PJn3k94BymXMmurw,89909
+pypdf/_page_labels.py,sha256=_HXqgEhSLTH_mMhy8m4QAOzIOHRQLV6_lYvg81-l9hI,8546
+pypdf/_protocols.py,sha256=7qz92LVdPrYkSpdUPpAp9U4GW5jxNBTfVcpUWwUhEOo,2123
+pypdf/_reader.py,sha256=KyeDHVEI5n4cZBHGVzbGIfhaPC1nZMiIU0W_ZNb0w_Y,55079
+pypdf/_text_extraction/__init__.py,sha256=a3Z33rQVTiMKGtwt7_bfXlPosbST8rzELoNnt053_Qw,8515
+pypdf/_text_extraction/__pycache__/__init__.cpython-312.pyc,,
+pypdf/_text_extraction/__pycache__/_text_extractor.cpython-312.pyc,,
+pypdf/_text_extraction/_layout_mode/__init__.py,sha256=RUQIwiUwzneNtcljnVM6jkRaem6pgP7mOD2-MBmtpvw,340
+pypdf/_text_extraction/_layout_mode/__pycache__/__init__.cpython-312.pyc,,
+pypdf/_text_extraction/_layout_mode/__pycache__/_fixed_width_page.cpython-312.pyc,,
+pypdf/_text_extraction/_layout_mode/__pycache__/_text_state_manager.cpython-312.pyc,,
+pypdf/_text_extraction/_layout_mode/__pycache__/_text_state_params.cpython-312.pyc,,
+pypdf/_text_extraction/_layout_mode/_fixed_width_page.py,sha256=eJveDbyMooG970qJOhM5Rwb9ZoyyJDynzWpV9a7IS20,15370
+pypdf/_text_extraction/_layout_mode/_text_state_manager.py,sha256=XVrIjeTd5jSdMexBQxs0tL5I5RUOitRmN1mELOcKYm4,8221
+pypdf/_text_extraction/_layout_mode/_text_state_params.py,sha256=hyw6pnC8upBkoFVUJ3LH8hBIIHrNwiqaqcYyzIIyr6Y,5481
+pypdf/_text_extraction/_text_extractor.py,sha256=wRmFtgMYTbJFbZRJVG3j1-lQWhb6mUC5uiE73DLRhIo,14454
+pypdf/_utils.py,sha256=v579jJEHn-JophTC4Ej2MBFTEoQGitPWs_d507pyS6g,20194
+pypdf/_version.py,sha256=S2Qku7VqFDmWPW_O3fID47IPC76TVFqesX1qVVa575w,22
+pypdf/_writer.py,sha256=K7ANMEgNz-tPngYVMW9j07SEcksk5tFf1_tgi0JDRIg,129793
+pypdf/_xobj_image_helpers.py,sha256=y7EMrXlYqwbIeUtdQS2XH9nO_2R73DOLf9-T1IyHMIA,21450
+pypdf/annotations/__init__.py,sha256=f2k_-jAn39CCB27KxQ_e93GinnzkAHbUnnSeGJl1jyE,990
+pypdf/annotations/__pycache__/__init__.cpython-312.pyc,,
+pypdf/annotations/__pycache__/_base.cpython-312.pyc,,
+pypdf/annotations/__pycache__/_markup_annotations.cpython-312.pyc,,
+pypdf/annotations/__pycache__/_non_markup_annotations.cpython-312.pyc,,
+pypdf/annotations/_base.py,sha256=eeoc9v2w15jAUhKXj48l1bB66YgBgV-2v5IIUJH-vws,961
+pypdf/annotations/_markup_annotations.py,sha256=PLDCbsEWSgOmk6HTxepolEzj-Q3EE5J4hXMgnTDFaqc,9590
+pypdf/annotations/_non_markup_annotations.py,sha256=Z2IUvcCOcTcpJhSXrex_9riYM2D64XxFQ_vac10BNRU,3649
+pypdf/constants.py,sha256=_U_xkH1REx2rsgtx3jCOaKivhmyqPA25PLL7Z4A1_ZI,23260
+pypdf/errors.py,sha256=Bw1W9hxOsDgwqwU6YoQ2l0-JiUyTq6l5QjVCr-W4GFA,1947
+pypdf/filters.py,sha256=FzfrqdZK9bs3MjU75KJ2uIMPpx6VcxYQ4oV9wLh3j-w,29210
+pypdf/generic/__init__.py,sha256=VrqdYftQECePDU2rXVMgEqRaYFR8zOV_fvJgo19x_uw,3468
+pypdf/generic/__pycache__/__init__.cpython-312.pyc,,
+pypdf/generic/__pycache__/_appearance_stream.cpython-312.pyc,,
+pypdf/generic/__pycache__/_base.cpython-312.pyc,,
+pypdf/generic/__pycache__/_data_structures.cpython-312.pyc,,
+pypdf/generic/__pycache__/_files.cpython-312.pyc,,
+pypdf/generic/__pycache__/_fit.cpython-312.pyc,,
+pypdf/generic/__pycache__/_image_inline.cpython-312.pyc,,
+pypdf/generic/__pycache__/_link.cpython-312.pyc,,
+pypdf/generic/__pycache__/_outline.cpython-312.pyc,,
+pypdf/generic/__pycache__/_rectangle.cpython-312.pyc,,
+pypdf/generic/__pycache__/_utils.cpython-312.pyc,,
+pypdf/generic/__pycache__/_viewerpref.cpython-312.pyc,,
+pypdf/generic/_appearance_stream.py,sha256=ofXHlJC4-jSBCLOhkKztoeFiYlD-zi8QMdvRrMm3rdE,24867
+pypdf/generic/_base.py,sha256=N8O_NcqK5y5O70OF8-p6vsac9R1ykTDcBIksBY_9rnA,32531
+pypdf/generic/_data_structures.py,sha256=g1Jy5tpPSTHIhOme6HFXdMvxV2HuxbZx-HOsF2Awdc0,63602
+pypdf/generic/_files.py,sha256=NtSkRo6JBgisi4QOyrVneO891boVsuY25hRwij6X9RA,16238
+pypdf/generic/_fit.py,sha256=X_iADJj1YY4PUStS7rFWC2xR2LUVSvKtUAky0AFAIDM,5515
+pypdf/generic/_image_inline.py,sha256=4cADiCeaCYq2kgJu0wOYXRn5YZ27cCHb3hGFqFFT5D4,12787
+pypdf/generic/_link.py,sha256=ibdLhdU0mP_phneaJs-CzUDErkJuqnMT6TsQoHNOYiE,4951
+pypdf/generic/_outline.py,sha256=qKbMX42OWfqnopIiE6BUy6EvdTLGe3ZtjaiWN85JpaY,1094
+pypdf/generic/_rectangle.py,sha256=lOqSfFivQxgBN9LU9aqHoxPH8aCPTDUNgRZsNEUd6fc,3785
+pypdf/generic/_utils.py,sha256=vTDAesfG-cJNDKilz_kbgFodAITzd5ejppWHGjvConk,7258
+pypdf/generic/_viewerpref.py,sha256=6a_s0Avm9-XvV0wqxiW23cE92qK98ry3y6EPjfsFSdo,6758
+pypdf/pagerange.py,sha256=2bt21jQZm-9aq2bVf3TXuH8_wGVx7b9T6UrMFXCEJhQ,7108
+pypdf/papersizes.py,sha256=6Tz5sfNN_3JOUapY83U-lakohnpXYA0hSEQNmOVLFL8,1413
+pypdf/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypdf/types.py,sha256=sJ7wHzk7ER_CJ7kP-s8u9axFnkCXnFpr8nzcj1AxTas,1915
+pypdf/xmp.py,sha256=gqh3IlgTNP7ZuyhvE59p2tsMvu4adGkq0G8RDg0OtQw,29238
diff --git a/venv/lib/python3.12/site-packages/pypdf-6.6.2.dist-info/REQUESTED b/venv/lib/python3.12/site-packages/pypdf-6.6.2.dist-info/REQUESTED
new file mode 100644
index 0000000..e69de29
diff --git a/venv/lib/python3.12/site-packages/pypdf-6.6.2.dist-info/WHEEL b/venv/lib/python3.12/site-packages/pypdf-6.6.2.dist-info/WHEEL
new file mode 100644
index 0000000..d8b9936
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf-6.6.2.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/venv/lib/python3.12/site-packages/pypdf-6.6.2.dist-info/licenses/LICENSE b/venv/lib/python3.12/site-packages/pypdf-6.6.2.dist-info/licenses/LICENSE
new file mode 100644
index 0000000..ab327d0
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf-6.6.2.dist-info/licenses/LICENSE
@@ -0,0 +1,29 @@
+Copyright (c) 2006-2008, Mathieu Fenniak
+Some contributions copyright (c) 2007, Ashish Kulkarni
+Some contributions copyright (c) 2014, Steve Witham
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+* 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.
+* The name of the author may not be used to endorse or promote products
+derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
diff --git a/venv/lib/python3.12/site-packages/pypdf/__init__.py b/venv/lib/python3.12/site-packages/pypdf/__init__.py
new file mode 100644
index 0000000..793d4f1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/__init__.py
@@ -0,0 +1,48 @@
+"""
+pypdf is a free and open-source pure-python PDF library capable of splitting,
+merging, cropping, and transforming the pages of PDF files. It can also add
+custom data, viewing options, and passwords to PDF files. pypdf can retrieve
+text and metadata from PDFs as well.
+
+You can read the full docs at https://pypdf.readthedocs.io/.
+"""
+
+from ._crypt_providers import crypt_provider
+from ._doc_common import DocumentInformation
+from ._encryption import PasswordType
+from ._page import PageObject, Transformation
+from ._reader import PdfReader
+from ._text_extraction import mult
+from ._version import __version__
+from ._writer import ObjectDeletionFlag, PdfWriter
+from .constants import ImageType
+from .pagerange import PageRange, parse_filename_page_ranges
+from .papersizes import PaperSize
+
+try:
+ import PIL
+
+ pil_version = PIL.__version__
+except ImportError:
+ pil_version = "none"
+
+_debug_versions = (
+ f"pypdf=={__version__}, {crypt_provider=}, PIL={pil_version}"
+)
+
+__all__ = [
+ "DocumentInformation",
+ "ImageType",
+ "ObjectDeletionFlag",
+ "PageObject",
+ "PageRange",
+ "PaperSize",
+ "PasswordType",
+ "PdfReader",
+ "PdfWriter",
+ "Transformation",
+ "__version__",
+ "_debug_versions",
+ "mult",
+ "parse_filename_page_ranges",
+]
diff --git a/venv/lib/python3.12/site-packages/pypdf/_cmap.py b/venv/lib/python3.12/site-packages/pypdf/_cmap.py
new file mode 100644
index 0000000..5b6fdce
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_cmap.py
@@ -0,0 +1,338 @@
+import binascii
+from binascii import Error as BinasciiError
+from binascii import unhexlify
+from math import ceil
+from typing import Any, Union, cast
+
+from ._codecs import adobe_glyphs, charset_encoding
+from ._utils import logger_error, logger_warning
+from .generic import (
+ DecodedStreamObject,
+ DictionaryObject,
+ NullObject,
+ StreamObject,
+ is_null_or_none,
+)
+
+_predefined_cmap: dict[str, str] = {
+ "/Identity-H": "utf-16-be",
+ "/Identity-V": "utf-16-be",
+ "/GB-EUC-H": "gbk",
+ "/GB-EUC-V": "gbk",
+ "/GBpc-EUC-H": "gb2312",
+ "/GBpc-EUC-V": "gb2312",
+ "/GBK-EUC-H": "gbk",
+ "/GBK-EUC-V": "gbk",
+ "/GBK2K-H": "gb18030",
+ "/GBK2K-V": "gb18030",
+ "/ETen-B5-H": "cp950",
+ "/ETen-B5-V": "cp950",
+ "/ETenms-B5-H": "cp950",
+ "/ETenms-B5-V": "cp950",
+ "/UniCNS-UTF16-H": "utf-16-be",
+ "/UniCNS-UTF16-V": "utf-16-be",
+ "/UniGB-UTF16-H": "gb18030",
+ "/UniGB-UTF16-V": "gb18030",
+ # UCS2 in code
+}
+
+
+def get_encoding(
+ ft: DictionaryObject
+) -> tuple[Union[str, dict[int, str]], dict[Any, Any]]:
+ encoding = _parse_encoding(ft)
+ map_dict, int_entry = _parse_to_unicode(ft)
+
+ # Apply rule from PDF ref 1.7 §5.9.1, 1st bullet:
+ # if cmap not empty encoding should be discarded
+ # (here transformed into identity for those characters)
+ # If encoding is a string, it is expected to be an identity translation.
+ if isinstance(encoding, dict):
+ for x in int_entry:
+ if x <= 255:
+ encoding[x] = chr(x)
+
+ return encoding, map_dict
+
+
+def _parse_encoding(
+ ft: DictionaryObject
+) -> Union[str, dict[int, str]]:
+ encoding: Union[str, list[str], dict[int, str]] = []
+ if "/Encoding" not in ft:
+ if "/BaseFont" in ft and cast(str, ft["/BaseFont"]) in charset_encoding:
+ encoding = dict(
+ zip(range(256), charset_encoding[cast(str, ft["/BaseFont"])])
+ )
+ else:
+ encoding = "charmap"
+ return encoding
+ enc: Union[str, DictionaryObject, NullObject] = cast(
+ Union[str, DictionaryObject, NullObject], ft["/Encoding"].get_object()
+ )
+ if isinstance(enc, str):
+ try:
+ # already done : enc = NameObject.unnumber(enc.encode()).decode()
+ # for #xx decoding
+ if enc in charset_encoding:
+ encoding = charset_encoding[enc].copy()
+ elif enc in _predefined_cmap:
+ encoding = _predefined_cmap[enc]
+ elif "-UCS2-" in enc:
+ encoding = "utf-16-be"
+ else:
+ raise Exception("not found")
+ except Exception:
+ logger_error(f"Advanced encoding {enc} not implemented yet", __name__)
+ encoding = enc
+ elif isinstance(enc, DictionaryObject) and "/BaseEncoding" in enc:
+ try:
+ encoding = charset_encoding[cast(str, enc["/BaseEncoding"])].copy()
+ except Exception:
+ logger_error(
+ f"Advanced encoding {encoding} not implemented yet",
+ __name__,
+ )
+ encoding = charset_encoding["/StandardEncoding"].copy()
+ else:
+ encoding = charset_encoding["/StandardEncoding"].copy()
+ if isinstance(enc, DictionaryObject) and "/Differences" in enc:
+ x: int = 0
+ o: Union[int, str]
+ for o in cast(DictionaryObject, enc["/Differences"]):
+ if isinstance(o, int):
+ x = o
+ else: # isinstance(o, str):
+ try:
+ if x < len(encoding):
+ encoding[x] = adobe_glyphs[o] # type: ignore
+ except Exception:
+ encoding[x] = o # type: ignore
+ x += 1
+ if isinstance(encoding, list):
+ encoding = dict(zip(range(256), encoding))
+ return encoding
+
+
+def _parse_to_unicode(
+ ft: DictionaryObject
+) -> tuple[dict[Any, Any], list[int]]:
+ # will store all translation code
+ # and map_dict[-1] we will have the number of bytes to convert
+ map_dict: dict[Any, Any] = {}
+
+ # will provide the list of cmap keys as int to correct encoding
+ int_entry: list[int] = []
+
+ if "/ToUnicode" not in ft:
+ if ft.get("/Subtype", "") == "/Type1":
+ return _type1_alternative(ft, map_dict, int_entry)
+ return {}, []
+ process_rg: bool = False
+ process_char: bool = False
+ multiline_rg: Union[
+ None, tuple[int, int]
+ ] = None # tuple = (current_char, remaining size) ; cf #1285 for example of file
+ cm = prepare_cm(ft)
+ for line in cm.split(b"\n"):
+ process_rg, process_char, multiline_rg = process_cm_line(
+ line.strip(b" \t"),
+ process_rg,
+ process_char,
+ multiline_rg,
+ map_dict,
+ int_entry,
+ )
+
+ return map_dict, int_entry
+
+
+def prepare_cm(ft: DictionaryObject) -> bytes:
+ tu = ft["/ToUnicode"]
+ cm: bytes
+ if isinstance(tu, StreamObject):
+ cm = cast(DecodedStreamObject, ft["/ToUnicode"]).get_data()
+ else: # if (tu is None) or cast(str, tu).startswith("/Identity"):
+ # the full range 0000-FFFF will be processed
+ cm = b"beginbfrange\n<0000> <0001> <0000>\nendbfrange"
+ if isinstance(cm, str):
+ cm = cm.encode()
+ # we need to prepare cm before due to missing return line in pdf printed
+ # to pdf from word
+ cm = (
+ cm.strip()
+ .replace(b"beginbfchar", b"\nbeginbfchar\n")
+ .replace(b"endbfchar", b"\nendbfchar\n")
+ .replace(b"beginbfrange", b"\nbeginbfrange\n")
+ .replace(b"endbfrange", b"\nendbfrange\n")
+ .replace(b"<<", b"\n{\n") # text between << and >> not used but
+ .replace(b">>", b"\n}\n") # some solution to find it back
+ )
+ ll = cm.split(b"<")
+ for i in range(len(ll)):
+ j = ll[i].find(b">")
+ if j >= 0:
+ if j == 0:
+ # string is empty: stash a placeholder here (see below)
+ # see https://github.com/py-pdf/pypdf/issues/1111
+ content = b"."
+ else:
+ content = ll[i][:j].replace(b" ", b"")
+ ll[i] = content + b" " + ll[i][j + 1 :]
+ cm = (
+ (b" ".join(ll))
+ .replace(b"[", b" [ ")
+ .replace(b"]", b" ]\n ")
+ .replace(b"\r", b"\n")
+ )
+ return cm
+
+
+def process_cm_line(
+ line: bytes,
+ process_rg: bool,
+ process_char: bool,
+ multiline_rg: Union[None, tuple[int, int]],
+ map_dict: dict[Any, Any],
+ int_entry: list[int],
+) -> tuple[bool, bool, Union[None, tuple[int, int]]]:
+ if line == b"" or line[0] == 37: # 37 = %
+ return process_rg, process_char, multiline_rg
+ line = line.replace(b"\t", b" ")
+ if b"beginbfrange" in line:
+ process_rg = True
+ elif b"endbfrange" in line:
+ process_rg = False
+ elif b"beginbfchar" in line:
+ process_char = True
+ elif b"endbfchar" in line:
+ process_char = False
+ elif process_rg:
+ try:
+ multiline_rg = parse_bfrange(line, map_dict, int_entry, multiline_rg)
+ except binascii.Error as error:
+ logger_warning(f"Skipping broken line {line!r}: {error}", __name__)
+ elif process_char:
+ parse_bfchar(line, map_dict, int_entry)
+ return process_rg, process_char, multiline_rg
+
+
+def parse_bfrange(
+ line: bytes,
+ map_dict: dict[Any, Any],
+ int_entry: list[int],
+ multiline_rg: Union[None, tuple[int, int]],
+) -> Union[None, tuple[int, int]]:
+ lst = [x for x in line.split(b" ") if x]
+ closure_found = False
+ if multiline_rg is not None:
+ fmt = b"%%0%dX" % (map_dict[-1] * 2)
+ a = multiline_rg[0] # a, b not in the current line
+ b = multiline_rg[1]
+ for sq in lst:
+ if sq == b"]":
+ closure_found = True
+ break
+ map_dict[
+ unhexlify(fmt % a).decode(
+ "charmap" if map_dict[-1] == 1 else "utf-16-be",
+ "surrogatepass",
+ )
+ ] = unhexlify(sq).decode("utf-16-be", "surrogatepass")
+ int_entry.append(a)
+ a += 1
+ else:
+ a = int(lst[0], 16)
+ b = int(lst[1], 16)
+ nbi = max(len(lst[0]), len(lst[1]))
+ map_dict[-1] = ceil(nbi / 2)
+ fmt = b"%%0%dX" % (map_dict[-1] * 2)
+ if lst[2] == b"[":
+ for sq in lst[3:]:
+ if sq == b"]":
+ closure_found = True
+ break
+ map_dict[
+ unhexlify(fmt % a).decode(
+ "charmap" if map_dict[-1] == 1 else "utf-16-be",
+ "surrogatepass",
+ )
+ ] = unhexlify(sq).decode("utf-16-be", "surrogatepass")
+ int_entry.append(a)
+ a += 1
+ else: # case without list
+ c = int(lst[2], 16)
+ fmt2 = b"%%0%dX" % max(4, len(lst[2]))
+ closure_found = True
+ while a <= b:
+ map_dict[
+ unhexlify(fmt % a).decode(
+ "charmap" if map_dict[-1] == 1 else "utf-16-be",
+ "surrogatepass",
+ )
+ ] = unhexlify(fmt2 % c).decode("utf-16-be", "surrogatepass")
+ int_entry.append(a)
+ a += 1
+ c += 1
+ return None if closure_found else (a, b)
+
+
+def parse_bfchar(line: bytes, map_dict: dict[Any, Any], int_entry: list[int]) -> None:
+ lst = [x for x in line.split(b" ") if x]
+ map_dict[-1] = len(lst[0]) // 2
+ while len(lst) > 1:
+ map_to = ""
+ # placeholder (see above) means empty string
+ if lst[1] != b".":
+ try:
+ map_to = unhexlify(lst[1]).decode(
+ "charmap" if len(lst[1]) < 4 else "utf-16-be", "surrogatepass"
+ ) # join is here as some cases where the code was split
+ except BinasciiError as exception:
+ logger_warning(f"Got invalid hex string: {exception!s} ({lst[1]!r})", __name__)
+ map_dict[
+ unhexlify(lst[0]).decode(
+ "charmap" if map_dict[-1] == 1 else "utf-16-be", "surrogatepass"
+ )
+ ] = map_to
+ int_entry.append(int(lst[0], 16))
+ lst = lst[2:]
+
+
+def _type1_alternative(
+ ft: DictionaryObject,
+ map_dict: dict[Any, Any],
+ int_entry: list[int],
+) -> tuple[dict[Any, Any], list[int]]:
+ if "/FontDescriptor" not in ft:
+ return map_dict, int_entry
+ ft_desc = cast(DictionaryObject, ft["/FontDescriptor"]).get("/FontFile")
+ if is_null_or_none(ft_desc):
+ return map_dict, int_entry
+ assert ft_desc is not None, "mypy"
+ txt = ft_desc.get_object().get_data()
+ txt = txt.split(b"eexec\n")[0] # only clear part
+ txt = txt.split(b"/Encoding")[1] # to get the encoding part
+ lines = txt.replace(b"\r", b"\n").split(b"\n")
+ for li in lines:
+ if li.startswith(b"dup"):
+ words = [_w for _w in li.split(b" ") if _w != b""]
+ if len(words) > 3 and words[3] != b"put":
+ continue
+ try:
+ i = int(words[1])
+ except ValueError: # pragma: no cover
+ continue
+ try:
+ v = adobe_glyphs[words[2].decode()]
+ except KeyError:
+ if words[2].startswith(b"/uni"):
+ try:
+ v = chr(int(words[2][4:], 16))
+ except ValueError: # pragma: no cover
+ continue
+ else:
+ continue
+ map_dict[chr(i)] = v
+ int_entry.append(i)
+ return map_dict, int_entry
diff --git a/venv/lib/python3.12/site-packages/pypdf/_codecs/__init__.py b/venv/lib/python3.12/site-packages/pypdf/_codecs/__init__.py
new file mode 100644
index 0000000..841e3fd
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_codecs/__init__.py
@@ -0,0 +1,59 @@
+from .adobe_glyphs import adobe_glyphs
+from .pdfdoc import _pdfdoc_encoding
+from .std import _std_encoding
+from .symbol import _symbol_encoding
+from .zapfding import _zapfding_encoding
+
+
+def fill_from_encoding(enc: str) -> list[str]:
+ lst: list[str] = []
+ for x in range(256):
+ try:
+ lst += (bytes((x,)).decode(enc),)
+ except Exception:
+ lst += (chr(x),)
+ return lst
+
+
+def rev_encoding(enc: list[str]) -> dict[str, int]:
+ rev: dict[str, int] = {}
+ for i in range(256):
+ char = enc[i]
+ if char == "\u0000":
+ continue
+ assert char not in rev, f"{char} at {i} already at {rev[char]}"
+ rev[char] = i
+ return rev
+
+
+_win_encoding = fill_from_encoding("cp1252")
+_mac_encoding = fill_from_encoding("mac_roman")
+
+
+_win_encoding_rev: dict[str, int] = rev_encoding(_win_encoding)
+_mac_encoding_rev: dict[str, int] = rev_encoding(_mac_encoding)
+_symbol_encoding_rev: dict[str, int] = rev_encoding(_symbol_encoding)
+_zapfding_encoding_rev: dict[str, int] = rev_encoding(_zapfding_encoding)
+_pdfdoc_encoding_rev: dict[str, int] = rev_encoding(_pdfdoc_encoding)
+
+
+charset_encoding: dict[str, list[str]] = {
+ "/StandardEncoding": _std_encoding,
+ "/WinAnsiEncoding": _win_encoding,
+ "/MacRomanEncoding": _mac_encoding,
+ "/PDFDocEncoding": _pdfdoc_encoding,
+ "/Symbol": _symbol_encoding,
+ "/ZapfDingbats": _zapfding_encoding,
+}
+
+__all__ = [
+ "_mac_encoding",
+ "_pdfdoc_encoding",
+ "_pdfdoc_encoding_rev",
+ "_std_encoding",
+ "_symbol_encoding",
+ "_win_encoding",
+ "_zapfding_encoding",
+ "adobe_glyphs",
+ "charset_encoding",
+]
diff --git a/venv/lib/python3.12/site-packages/pypdf/_codecs/_codecs.py b/venv/lib/python3.12/site-packages/pypdf/_codecs/_codecs.py
new file mode 100644
index 0000000..93f95e5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_codecs/_codecs.py
@@ -0,0 +1,281 @@
+"""
+This module is for codecs only.
+
+While the codec implementation can contain details of the PDF specification,
+the module should not do any PDF parsing.
+"""
+
+import io
+from abc import ABC, abstractmethod
+
+from pypdf._utils import logger_warning
+from pypdf.errors import LimitReachedError
+
+
+class Codec(ABC):
+ """Abstract base class for all codecs."""
+
+ @abstractmethod
+ def encode(self, data: bytes) -> bytes:
+ """
+ Encode the input data.
+
+ Args:
+ data: Data to encode.
+
+ Returns:
+ Encoded data.
+
+ """
+
+ @abstractmethod
+ def decode(self, data: bytes) -> bytes:
+ """
+ Decode the input data.
+
+ Args:
+ data: Data to decode.
+
+ Returns:
+ Decoded data.
+
+ """
+
+
+class LzwCodec(Codec):
+ """Lempel-Ziv-Welch (LZW) adaptive compression codec."""
+
+ CLEAR_TABLE_MARKER = 256 # Special code to indicate table reset
+ EOD_MARKER = 257 # End-of-data marker
+ INITIAL_BITS_PER_CODE = 9 # Initial code bit width
+ MAX_BITS_PER_CODE = 12 # Maximum code bit width
+
+ def __init__(self, max_output_length: int = 75_000_000) -> None:
+ self.max_output_length = max_output_length
+
+ def _initialize_encoding_table(self) -> None:
+ """Initialize the encoding table and state to initial conditions."""
+ self.encoding_table: dict[bytes, int] = {bytes([i]): i for i in range(256)}
+ self.next_code = self.EOD_MARKER + 1
+ self.bits_per_code = self.INITIAL_BITS_PER_CODE
+ self.max_code_value = (1 << self.bits_per_code) - 1
+
+ def _increase_next_code(self) -> None:
+ """Update bits_per_code and max_code_value if necessary."""
+ self.next_code += 1
+ if (
+ self.next_code > self.max_code_value
+ and self.bits_per_code < self.MAX_BITS_PER_CODE
+ ):
+ self.bits_per_code += 1
+ self.max_code_value = (1 << self.bits_per_code) - 1
+
+ def encode(self, data: bytes) -> bytes:
+ """
+ Encode data using the LZW compression algorithm.
+
+ Taken from PDF 1.7 specs, "7.4.4.2 Details of LZW Encoding".
+ """
+ result_codes: list[int] = []
+
+ # The encoder shall begin by issuing a clear-table code
+ result_codes.append(self.CLEAR_TABLE_MARKER)
+ self._initialize_encoding_table()
+
+ current_sequence = b""
+ for byte in data:
+ next_sequence = current_sequence + bytes([byte])
+
+ if next_sequence in self.encoding_table:
+ # Extend current sequence if already in the table
+ current_sequence = next_sequence
+ else:
+ # Output code for the current sequence
+ result_codes.append(self.encoding_table[current_sequence])
+
+ # Add the new sequence to the table if there's room
+ if self.next_code <= (1 << self.MAX_BITS_PER_CODE) - 1:
+ self.encoding_table[next_sequence] = self.next_code
+ self._increase_next_code()
+ else:
+ # If the table is full, emit a clear-table command
+ result_codes.append(self.CLEAR_TABLE_MARKER)
+ self._initialize_encoding_table()
+
+ # Start new sequence
+ current_sequence = bytes([byte])
+
+ # Ensure everything actually is encoded
+ if current_sequence:
+ result_codes.append(self.encoding_table[current_sequence])
+ result_codes.append(self.EOD_MARKER)
+
+ return self._pack_codes_into_bytes(result_codes)
+
+ def _pack_codes_into_bytes(self, codes: list[int]) -> bytes:
+ """
+ Convert the list of result codes into a continuous byte stream, with codes packed as per the code bit-width.
+ The bit-width starts at 9 bits and expands as needed.
+ """
+ self._initialize_encoding_table()
+ buffer = 0
+ bits_in_buffer = 0
+ output = bytearray()
+
+ for code in codes:
+ buffer = (buffer << self.bits_per_code) | code
+ bits_in_buffer += self.bits_per_code
+
+ # Codes shall be packed into a continuous bit stream, high-order bit
+ # first. This stream shall then be divided into bytes, high-order bit
+ # first.
+ while bits_in_buffer >= 8:
+ bits_in_buffer -= 8
+ output.append((buffer >> bits_in_buffer) & 0xFF)
+
+ if code == self.CLEAR_TABLE_MARKER:
+ self._initialize_encoding_table()
+ elif code == self.EOD_MARKER:
+ continue
+ else:
+ self._increase_next_code()
+
+ # Flush any remaining bits in the buffer
+ if bits_in_buffer > 0:
+ output.append((buffer << (8 - bits_in_buffer)) & 0xFF)
+
+ return bytes(output)
+
+ def _initialize_decoding_table(self) -> None:
+ self.max_code_value = (1 << self.MAX_BITS_PER_CODE) - 1
+ self.decoding_table = [bytes([i]) for i in range(self.CLEAR_TABLE_MARKER)] + [
+ b""
+ ] * (self.max_code_value - self.CLEAR_TABLE_MARKER + 1)
+ self._table_index = self.EOD_MARKER + 1
+ self._bits_to_get = 9
+
+ def _next_code_decode(self, data: bytes) -> int:
+ self._next_data: int
+ try:
+ while self._next_bits < self._bits_to_get:
+ self._next_data = (self._next_data << 8) | (
+ data[self._byte_pointer]
+ )
+ self._byte_pointer += 1
+ self._next_bits += 8
+
+ code = (
+ self._next_data >> (self._next_bits - self._bits_to_get)
+ ) & self._and_table[self._bits_to_get - 9]
+ self._next_bits -= self._bits_to_get
+
+ # Reduce data to get rid of the overhead,
+ # which increases performance on large streams significantly.
+ self._next_data = self._next_data & 0xFFFFF
+
+ return code
+ except IndexError:
+ return self.EOD_MARKER
+
+ # The following method has been converted to Python from PDFsharp:
+ # https://github.com/empira/PDFsharp/blob/5fbf6ed14740bc4e16786816882d32e43af3ff5d/src/foundation/src/PDFsharp/src/PdfSharp/Pdf.Filters/LzwDecode.cs
+ #
+ # Original license:
+ #
+ # -------------------------------------------------------------------------
+ # Copyright (c) 2001-2024 empira Software GmbH, Troisdorf (Cologne Area),
+ # Germany
+ #
+ # http://docs.pdfsharp.net
+ #
+ # MIT License
+ #
+ # Permission is hereby granted, free of charge, to any person obtaining a
+ # copy of this software and associated documentation files (the "Software"),
+ # to deal in the Software without restriction, including without limitation
+ # the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ # and/or sell copies of the Software, and to permit persons to whom the
+ # Software is furnished to do so, subject to the following conditions:
+ #
+ # The above copyright notice and this permission notice shall be included
+ # in all copies or substantial portions of the Software.
+ #
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ # DEALINGS IN THE SOFTWARE.
+ # --------------------------------------------------------------------------
+ def decode(self, data: bytes) -> bytes:
+ """
+ The following code was converted to Python from the following code:
+ https://github.com/empira/PDFsharp/blob/master/src/foundation/src/PDFsharp/src/PdfSharp/Pdf.Filters/LzwDecode.cs
+ """
+ self._and_table = [511, 1023, 2047, 4095]
+ self._table_index = 0
+ self._bits_to_get = 9
+ self._byte_pointer = 0
+ self._next_data = 0
+ self._next_bits = 0
+
+ output_stream = io.BytesIO()
+ output_length = 0
+
+ self._initialize_decoding_table()
+ self._byte_pointer = 0
+ self._next_data = 0
+ self._next_bits = 0
+ old_code = self.CLEAR_TABLE_MARKER
+
+ while True:
+ code = self._next_code_decode(data)
+ if code == self.EOD_MARKER:
+ break
+
+ if code == self.CLEAR_TABLE_MARKER:
+ self._initialize_decoding_table()
+ code = self._next_code_decode(data)
+ if code == self.EOD_MARKER:
+ break
+ output_stream.write(decoded := self.decoding_table[code])
+ old_code = code
+ elif code < self._table_index:
+ decoded = self.decoding_table[code]
+ output_stream.write(decoded)
+ if old_code != self.CLEAR_TABLE_MARKER:
+ self._add_entry_decode(self.decoding_table[old_code], decoded[0])
+ old_code = code
+ else:
+ # The code is not in the table and not one of the special codes
+ decoded = (
+ self.decoding_table[old_code] + self.decoding_table[old_code][:1]
+ )
+ output_stream.write(decoded)
+ self._add_entry_decode(self.decoding_table[old_code], decoded[0])
+ old_code = code
+
+ output_length += len(decoded)
+ if output_length > self.max_output_length:
+ raise LimitReachedError(
+ f"Limit reached while decompressing: {output_length} > {self.max_output_length}"
+ )
+
+ return output_stream.getvalue()
+
+ def _add_entry_decode(self, old_string: bytes, new_char: int) -> None:
+ new_string = old_string + bytes([new_char])
+ if self._table_index > self.max_code_value:
+ logger_warning("Ignoring too large LZW table index.", __name__)
+ return
+ self.decoding_table[self._table_index] = new_string
+ self._table_index += 1
+
+ # Update the number of bits to get based on the table index
+ if self._table_index == 511:
+ self._bits_to_get = 10
+ elif self._table_index == 1023:
+ self._bits_to_get = 11
+ elif self._table_index == 2047:
+ self._bits_to_get = 12
diff --git a/venv/lib/python3.12/site-packages/pypdf/_codecs/adobe_glyphs.py b/venv/lib/python3.12/site-packages/pypdf/_codecs/adobe_glyphs.py
new file mode 100644
index 0000000..72d5ed3
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_codecs/adobe_glyphs.py
@@ -0,0 +1,13969 @@
+# https://raw.githubusercontent.com/adobe-type-tools/agl-aglfn/master/glyphlist.txt
+
+# converted manually to python
+# Extended with data from GlyphNameFormatter:
+# https://github.com/LettError/glyphNameFormatter
+
+# -----------------------------------------------------------
+# Copyright 2002-2019 Adobe (http://www.adobe.com/).
+#
+# Redistribution and use in source and binary forms, with or
+# without modification, are permitted provided that the
+# following conditions are met:
+#
+# Redistributions of source code must retain the above
+# copyright notice, this list of conditions and the following
+# disclaimer.
+#
+# 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.
+#
+# Neither the name of Adobe nor the names of its contributors
+# may be used to endorse or promote products derived from this
+# software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+# CONTRIBUTORS "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 THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS 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.
+# -----------------------------------------------------------
+# Name: Adobe Glyph List
+# Table version: 2.0
+# Date: September 20, 2002
+# URL: https://github.com/adobe-type-tools/agl-aglfn
+#
+# Format: two semicolon-delimited fields:
+# (1) glyph name--upper/lowercase letters and digits
+# (2) Unicode scalar value--four uppercase hexadecimal digits
+#
+adobe_glyphs = {
+ "/A": "\u0041",
+ "/AA": "\uA732",
+ "/AE": "\u00C6",
+ "/AEacute": "\u01FC",
+ "/AEmacron": "\u01E2",
+ "/AEsmall": "\uF7E6",
+ "/AO": "\uA734",
+ "/AU": "\uA736",
+ "/AV": "\uA738",
+ "/AVhorizontalbar": "\uA73A",
+ "/AY": "\uA73C",
+ "/Aacute": "\u00C1",
+ "/Aacutesmall": "\uF7E1",
+ "/Abreve": "\u0102",
+ "/Abreveacute": "\u1EAE",
+ "/Abrevecyr": "\u04D0",
+ "/Abrevecyrillic": "\u04D0",
+ "/Abrevedotbelow": "\u1EB6",
+ "/Abrevegrave": "\u1EB0",
+ "/Abrevehoi": "\u1EB2",
+ "/Abrevehookabove": "\u1EB2",
+ "/Abrevetilde": "\u1EB4",
+ "/Acaron": "\u01CD",
+ "/Acircle": "\u24B6",
+ "/Acircleblack": "\u1F150",
+ "/Acircumflex": "\u00C2",
+ "/Acircumflexacute": "\u1EA4",
+ "/Acircumflexdotbelow": "\u1EAC",
+ "/Acircumflexgrave": "\u1EA6",
+ "/Acircumflexhoi": "\u1EA8",
+ "/Acircumflexhookabove": "\u1EA8",
+ "/Acircumflexsmall": "\uF7E2",
+ "/Acircumflextilde": "\u1EAA",
+ "/Acute": "\uF6C9",
+ "/Acutesmall": "\uF7B4",
+ "/Acyr": "\u0410",
+ "/Acyrillic": "\u0410",
+ "/Adblgrave": "\u0200",
+ "/Adieresis": "\u00C4",
+ "/Adieresiscyr": "\u04D2",
+ "/Adieresiscyrillic": "\u04D2",
+ "/Adieresismacron": "\u01DE",
+ "/Adieresissmall": "\uF7E4",
+ "/Adot": "\u0226",
+ "/Adotbelow": "\u1EA0",
+ "/Adotmacron": "\u01E0",
+ "/Agrave": "\u00C0",
+ "/Agravedbl": "\u0200",
+ "/Agravesmall": "\uF7E0",
+ "/Ahoi": "\u1EA2",
+ "/Ahookabove": "\u1EA2",
+ "/Aiecyr": "\u04D4",
+ "/Aiecyrillic": "\u04D4",
+ "/Ainvertedbreve": "\u0202",
+ "/Akbar": "\uFDF3",
+ "/Alayhe": "\uFDF7",
+ "/Allah": "\uFDF2",
+ "/Alpha": "\u0391",
+ "/Alphaacute": "\u1FBB",
+ "/Alphaasper": "\u1F09",
+ "/Alphaasperacute": "\u1F0D",
+ "/Alphaasperacuteiotasub": "\u1F8D",
+ "/Alphaaspergrave": "\u1F0B",
+ "/Alphaaspergraveiotasub": "\u1F8B",
+ "/Alphaasperiotasub": "\u1F89",
+ "/Alphaaspertilde": "\u1F0F",
+ "/Alphaaspertildeiotasub": "\u1F8F",
+ "/Alphabreve": "\u1FB8",
+ "/Alphagrave": "\u1FBA",
+ "/Alphaiotasub": "\u1FBC",
+ "/Alphalenis": "\u1F08",
+ "/Alphalenisacute": "\u1F0C",
+ "/Alphalenisacuteiotasub": "\u1F8C",
+ "/Alphalenisgrave": "\u1F0A",
+ "/Alphalenisgraveiotasub": "\u1F8A",
+ "/Alphalenisiotasub": "\u1F88",
+ "/Alphalenistilde": "\u1F0E",
+ "/Alphalenistildeiotasub": "\u1F8E",
+ "/Alphatonos": "\u0386",
+ "/Alphawithmacron": "\u1FB9",
+ "/Amacron": "\u0100",
+ "/Amonospace": "\uFF21",
+ "/Aogonek": "\u0104",
+ "/Aparens": "\u1F110",
+ "/Aring": "\u00C5",
+ "/Aringacute": "\u01FA",
+ "/Aringbelow": "\u1E00",
+ "/Aringsmall": "\uF7E5",
+ "/Asmall": "\uF761",
+ "/Asquare": "\u1F130",
+ "/Asquareblack": "\u1F170",
+ "/Astroke": "\u023A",
+ "/Atilde": "\u00C3",
+ "/Atildesmall": "\uF7E3",
+ "/Aturned": "\u2C6F",
+ "/Ayahend": "\u06DD",
+ "/Aybarmenian": "\u0531",
+ "/B": "\u0042",
+ "/Bcircle": "\u24B7",
+ "/Bcircleblack": "\u1F151",
+ "/Bdot": "\u1E02",
+ "/Bdotaccent": "\u1E02",
+ "/Bdotbelow": "\u1E04",
+ "/Becyr": "\u0411",
+ "/Becyrillic": "\u0411",
+ "/Benarmenian": "\u0532",
+ "/Beta": "\u0392",
+ "/Bflourish": "\uA796",
+ "/Bhook": "\u0181",
+ "/BismillahArRahmanArRaheem": "\uFDFD",
+ "/Blinebelow": "\u1E06",
+ "/Bmonospace": "\uFF22",
+ "/Bparens": "\u1F111",
+ "/Brevesmall": "\uF6F4",
+ "/Bscript": "\u212C",
+ "/Bsmall": "\uF762",
+ "/Bsquare": "\u1F131",
+ "/Bsquareblack": "\u1F171",
+ "/Bstroke": "\u0243",
+ "/Btopbar": "\u0182",
+ "/C": "\u0043",
+ "/CDcircle": "\u1F12D",
+ "/Caarmenian": "\u053E",
+ "/Cacute": "\u0106",
+ "/Caron": "\uF6CA",
+ "/Caronsmall": "\uF6F5",
+ "/Cbar": "\uA792",
+ "/Ccaron": "\u010C",
+ "/Ccedilla": "\u00C7",
+ "/Ccedillaacute": "\u1E08",
+ "/Ccedillasmall": "\uF7E7",
+ "/Ccircle": "\u24B8",
+ "/Ccircleblack": "\u1F152",
+ "/Ccircumflex": "\u0108",
+ "/Cdblstruck": "\u2102",
+ "/Cdot": "\u010A",
+ "/Cdotaccent": "\u010A",
+ "/Cdotreversed": "\uA73E",
+ "/Cedillasmall": "\uF7B8",
+ "/Cfraktur": "\u212D",
+ "/Chaarmenian": "\u0549",
+ "/Cheabkhasiancyrillic": "\u04BC",
+ "/Cheabkhcyr": "\u04BC",
+ "/Cheabkhtailcyr": "\u04BE",
+ "/Checyr": "\u0427",
+ "/Checyrillic": "\u0427",
+ "/Chedescenderabkhasiancyrillic": "\u04BE",
+ "/Chedescendercyrillic": "\u04B6",
+ "/Chedieresiscyr": "\u04F4",
+ "/Chedieresiscyrillic": "\u04F4",
+ "/Cheharmenian": "\u0543",
+ "/Chekhakascyr": "\u04CB",
+ "/Chekhakassiancyrillic": "\u04CB",
+ "/Chetailcyr": "\u04B6",
+ "/Chevertcyr": "\u04B8",
+ "/Cheverticalstrokecyrillic": "\u04B8",
+ "/Chi": "\u03A7",
+ "/Chook": "\u0187",
+ "/Circumflexsmall": "\uF6F6",
+ "/Citaliccircle": "\u1F12B",
+ "/Cmonospace": "\uFF23",
+ "/Coarmenian": "\u0551",
+ "/Con": "\uA76E",
+ "/Cparens": "\u1F112",
+ "/Csmall": "\uF763",
+ "/Csquare": "\u1F132",
+ "/Csquareblack": "\u1F172",
+ "/Cstretched": "\u0297",
+ "/Cstroke": "\u023B",
+ "/Cuatrillo": "\uA72C",
+ "/Cuatrillocomma": "\uA72E",
+ "/D": "\u0044",
+ "/DZ": "\u01F1",
+ "/DZcaron": "\u01C4",
+ "/Daarmenian": "\u0534",
+ "/Dafrican": "\u0189",
+ "/Dcaron": "\u010E",
+ "/Dcedilla": "\u1E10",
+ "/Dchecyr": "\u052C",
+ "/Dcircle": "\u24B9",
+ "/Dcircleblack": "\u1F153",
+ "/Dcircumflexbelow": "\u1E12",
+ "/Dcroat": "\u0110",
+ "/Ddblstruckitalic": "\u2145",
+ "/Ddot": "\u1E0A",
+ "/Ddotaccent": "\u1E0A",
+ "/Ddotbelow": "\u1E0C",
+ "/Decyr": "\u0414",
+ "/Decyrillic": "\u0414",
+ "/Deicoptic": "\u03EE",
+ "/Dekomicyr": "\u0500",
+ "/Delta": "\u2206",
+ "/Deltagreek": "\u0394",
+ "/Dhook": "\u018A",
+ "/Dieresis": "\uF6CB",
+ "/DieresisAcute": "\uF6CC",
+ "/DieresisGrave": "\uF6CD",
+ "/Dieresissmall": "\uF7A8",
+ "/Digamma": "\u03DC",
+ "/Digammagreek": "\u03DC",
+ "/Digammapamphylian": "\u0376",
+ "/Dinsular": "\uA779",
+ "/Djecyr": "\u0402",
+ "/Djecyrillic": "\u0402",
+ "/Djekomicyr": "\u0502",
+ "/Dlinebelow": "\u1E0E",
+ "/Dmonospace": "\uFF24",
+ "/Dotaccentsmall": "\uF6F7",
+ "/Dparens": "\u1F113",
+ "/Dslash": "\u0110",
+ "/Dsmall": "\uF764",
+ "/Dsquare": "\u1F133",
+ "/Dsquareblack": "\u1F173",
+ "/Dtopbar": "\u018B",
+ "/Dz": "\u01F2",
+ "/Dzcaron": "\u01C5",
+ "/Dzeabkhasiancyrillic": "\u04E0",
+ "/Dzeabkhcyr": "\u04E0",
+ "/Dzecyr": "\u0405",
+ "/Dzecyrillic": "\u0405",
+ "/Dzhecyr": "\u040F",
+ "/Dzhecyrillic": "\u040F",
+ "/Dzjekomicyr": "\u0506",
+ "/Dzzhecyr": "\u052A",
+ "/E": "\u0045",
+ "/Eacute": "\u00C9",
+ "/Eacutesmall": "\uF7E9",
+ "/Ebreve": "\u0114",
+ "/Ecaron": "\u011A",
+ "/Ecedilla": "\u0228",
+ "/Ecedillabreve": "\u1E1C",
+ "/Echarmenian": "\u0535",
+ "/Ecircle": "\u24BA",
+ "/Ecircleblack": "\u1F154",
+ "/Ecircumflex": "\u00CA",
+ "/Ecircumflexacute": "\u1EBE",
+ "/Ecircumflexbelow": "\u1E18",
+ "/Ecircumflexdotbelow": "\u1EC6",
+ "/Ecircumflexgrave": "\u1EC0",
+ "/Ecircumflexhoi": "\u1EC2",
+ "/Ecircumflexhookabove": "\u1EC2",
+ "/Ecircumflexsmall": "\uF7EA",
+ "/Ecircumflextilde": "\u1EC4",
+ "/Ecyrillic": "\u0404",
+ "/Edblgrave": "\u0204",
+ "/Edieresis": "\u00CB",
+ "/Edieresissmall": "\uF7EB",
+ "/Edot": "\u0116",
+ "/Edotaccent": "\u0116",
+ "/Edotbelow": "\u1EB8",
+ "/Efcyr": "\u0424",
+ "/Efcyrillic": "\u0424",
+ "/Egrave": "\u00C8",
+ "/Egravedbl": "\u0204",
+ "/Egravesmall": "\uF7E8",
+ "/Egyptain": "\uA724",
+ "/Egyptalef": "\uA722",
+ "/Eharmenian": "\u0537",
+ "/Ehoi": "\u1EBA",
+ "/Ehookabove": "\u1EBA",
+ "/Eightroman": "\u2167",
+ "/Einvertedbreve": "\u0206",
+ "/Eiotifiedcyr": "\u0464",
+ "/Eiotifiedcyrillic": "\u0464",
+ "/Elcyr": "\u041B",
+ "/Elcyrillic": "\u041B",
+ "/Elevenroman": "\u216A",
+ "/Elhookcyr": "\u0512",
+ "/Elmiddlehookcyr": "\u0520",
+ "/Elsharptailcyr": "\u04C5",
+ "/Eltailcyr": "\u052E",
+ "/Emacron": "\u0112",
+ "/Emacronacute": "\u1E16",
+ "/Emacrongrave": "\u1E14",
+ "/Emcyr": "\u041C",
+ "/Emcyrillic": "\u041C",
+ "/Emonospace": "\uFF25",
+ "/Emsharptailcyr": "\u04CD",
+ "/Encyr": "\u041D",
+ "/Encyrillic": "\u041D",
+ "/Endescendercyrillic": "\u04A2",
+ "/Eng": "\u014A",
+ "/Engecyr": "\u04A4",
+ "/Enghecyrillic": "\u04A4",
+ "/Enhookcyr": "\u04C7",
+ "/Enhookcyrillic": "\u04C7",
+ "/Enhookleftcyr": "\u0528",
+ "/Enmiddlehookcyr": "\u0522",
+ "/Ensharptailcyr": "\u04C9",
+ "/Entailcyr": "\u04A2",
+ "/Eogonek": "\u0118",
+ "/Eopen": "\u0190",
+ "/Eparens": "\u1F114",
+ "/Epsilon": "\u0395",
+ "/Epsilonacute": "\u1FC9",
+ "/Epsilonasper": "\u1F19",
+ "/Epsilonasperacute": "\u1F1D",
+ "/Epsilonaspergrave": "\u1F1B",
+ "/Epsilongrave": "\u1FC8",
+ "/Epsilonlenis": "\u1F18",
+ "/Epsilonlenisacute": "\u1F1C",
+ "/Epsilonlenisgrave": "\u1F1A",
+ "/Epsilontonos": "\u0388",
+ "/Ercyr": "\u0420",
+ "/Ercyrillic": "\u0420",
+ "/Ereversed": "\u018E",
+ "/Ereversedcyr": "\u042D",
+ "/Ereversedcyrillic": "\u042D",
+ "/Ereverseddieresiscyr": "\u04EC",
+ "/Ereversedopen": "\uA7AB",
+ "/Ertickcyr": "\u048E",
+ "/Escript": "\u2130",
+ "/Escyr": "\u0421",
+ "/Escyrillic": "\u0421",
+ "/Esdescendercyrillic": "\u04AA",
+ "/Esh": "\u01A9",
+ "/Esmall": "\uF765",
+ "/Esmallturned": "\u2C7B",
+ "/Esquare": "\u1F134",
+ "/Esquareblack": "\u1F174",
+ "/Estailcyr": "\u04AA",
+ "/Estroke": "\u0246",
+ "/Et": "\uA76A",
+ "/Eta": "\u0397",
+ "/Etaacute": "\u1FCB",
+ "/Etaasper": "\u1F29",
+ "/Etaasperacute": "\u1F2D",
+ "/Etaasperacuteiotasub": "\u1F9D",
+ "/Etaaspergrave": "\u1F2B",
+ "/Etaaspergraveiotasub": "\u1F9B",
+ "/Etaasperiotasub": "\u1F99",
+ "/Etaaspertilde": "\u1F2F",
+ "/Etaaspertildeiotasub": "\u1F9F",
+ "/Etagrave": "\u1FCA",
+ "/Etaiotasub": "\u1FCC",
+ "/Etalenis": "\u1F28",
+ "/Etalenisacute": "\u1F2C",
+ "/Etalenisacuteiotasub": "\u1F9C",
+ "/Etalenisgrave": "\u1F2A",
+ "/Etalenisgraveiotasub": "\u1F9A",
+ "/Etalenisiotasub": "\u1F98",
+ "/Etalenistilde": "\u1F2E",
+ "/Etalenistildeiotasub": "\u1F9E",
+ "/Etarmenian": "\u0538",
+ "/Etatonos": "\u0389",
+ "/Eth": "\u00D0",
+ "/Ethsmall": "\uF7F0",
+ "/Etilde": "\u1EBC",
+ "/Etildebelow": "\u1E1A",
+ "/Eukrcyr": "\u0404",
+ "/Euro": "\u20AC",
+ "/Ezh": "\u01B7",
+ "/Ezhcaron": "\u01EE",
+ "/Ezhreversed": "\u01B8",
+ "/F": "\u0046",
+ "/Fcircle": "\u24BB",
+ "/Fcircleblack": "\u1F155",
+ "/Fdot": "\u1E1E",
+ "/Fdotaccent": "\u1E1E",
+ "/Feharmenian": "\u0556",
+ "/Feicoptic": "\u03E4",
+ "/Fhook": "\u0191",
+ "/Finsular": "\uA77B",
+ "/Fitacyr": "\u0472",
+ "/Fitacyrillic": "\u0472",
+ "/Fiveroman": "\u2164",
+ "/Fmonospace": "\uFF26",
+ "/Fourroman": "\u2163",
+ "/Fparens": "\u1F115",
+ "/Fscript": "\u2131",
+ "/Fsmall": "\uF766",
+ "/Fsquare": "\u1F135",
+ "/Fsquareblack": "\u1F175",
+ "/Fstroke": "\uA798",
+ "/Fturned": "\u2132",
+ "/G": "\u0047",
+ "/GBsquare": "\u3387",
+ "/Gacute": "\u01F4",
+ "/Gamma": "\u0393",
+ "/Gammaafrican": "\u0194",
+ "/Gammadblstruck": "\u213E",
+ "/Gangiacoptic": "\u03EA",
+ "/Gbreve": "\u011E",
+ "/Gcaron": "\u01E6",
+ "/Gcedilla": "\u0122",
+ "/Gcircle": "\u24BC",
+ "/Gcircleblack": "\u1F156",
+ "/Gcircumflex": "\u011C",
+ "/Gcommaaccent": "\u0122",
+ "/Gdot": "\u0120",
+ "/Gdotaccent": "\u0120",
+ "/Gecyr": "\u0413",
+ "/Gecyrillic": "\u0413",
+ "/Gehookcyr": "\u0494",
+ "/Gehookstrokecyr": "\u04FA",
+ "/Germandbls": "\u1E9E",
+ "/Gestrokecyr": "\u0492",
+ "/Getailcyr": "\u04F6",
+ "/Geupcyr": "\u0490",
+ "/Ghadarmenian": "\u0542",
+ "/Ghemiddlehookcyrillic": "\u0494",
+ "/Ghestrokecyrillic": "\u0492",
+ "/Gheupturncyrillic": "\u0490",
+ "/Ghook": "\u0193",
+ "/Ghooksmall": "\u029B",
+ "/Gimarmenian": "\u0533",
+ "/Ginsular": "\uA77D",
+ "/Ginsularturned": "\uA77E",
+ "/Gjecyr": "\u0403",
+ "/Gjecyrillic": "\u0403",
+ "/Glottalstop": "\u0241",
+ "/Gmacron": "\u1E20",
+ "/Gmonospace": "\uFF27",
+ "/Gobliquestroke": "\uA7A0",
+ "/Gparens": "\u1F116",
+ "/Grave": "\uF6CE",
+ "/Gravesmall": "\uF760",
+ "/Gsmall": "\uF767",
+ "/Gsmallhook": "\u029B",
+ "/Gsquare": "\u1F136",
+ "/Gsquareblack": "\u1F176",
+ "/Gstroke": "\u01E4",
+ "/Gturnedsans": "\u2141",
+ "/H": "\u0048",
+ "/H18533": "\u25CF",
+ "/H18543": "\u25AA",
+ "/H18551": "\u25AB",
+ "/H22073": "\u25A1",
+ "/HPsquare": "\u33CB",
+ "/HVsquare": "\u1F14A",
+ "/Haabkhasiancyrillic": "\u04A8",
+ "/Haabkhcyr": "\u04A8",
+ "/Hacyr": "\u0425",
+ "/Hadescendercyrillic": "\u04B2",
+ "/Hahookcyr": "\u04FC",
+ "/Hardcyr": "\u042A",
+ "/Hardsigncyrillic": "\u042A",
+ "/Hastrokecyr": "\u04FE",
+ "/Hbar": "\u0126",
+ "/Hbrevebelow": "\u1E2A",
+ "/Hcaron": "\u021E",
+ "/Hcedilla": "\u1E28",
+ "/Hcircle": "\u24BD",
+ "/Hcircleblack": "\u1F157",
+ "/Hcircumflex": "\u0124",
+ "/Hdblstruck": "\u210D",
+ "/Hdescender": "\u2C67",
+ "/Hdieresis": "\u1E26",
+ "/Hdot": "\u1E22",
+ "/Hdotaccent": "\u1E22",
+ "/Hdotbelow": "\u1E24",
+ "/Heng": "\uA726",
+ "/Heta": "\u0370",
+ "/Hfraktur": "\u210C",
+ "/Hgfullwidth": "\u32CC",
+ "/Hhalf": "\u2C75",
+ "/Hhook": "\uA7AA",
+ "/Hmonospace": "\uFF28",
+ "/Hoarmenian": "\u0540",
+ "/HonAA": "\u0611",
+ "/HonRA": "\u0612",
+ "/HonSAW": "\u0610",
+ "/Horicoptic": "\u03E8",
+ "/Hparens": "\u1F117",
+ "/Hscript": "\u210B",
+ "/Hsmall": "\uF768",
+ "/Hsquare": "\u1F137",
+ "/Hsquareblack": "\u1F177",
+ "/Hstrokemod": "\uA7F8",
+ "/Hturned": "\uA78D",
+ "/Hungarumlaut": "\uF6CF",
+ "/Hungarumlautsmall": "\uF6F8",
+ "/Hwair": "\u01F6",
+ "/Hzsquare": "\u3390",
+ "/I": "\u0049",
+ "/IAcyrillic": "\u042F",
+ "/ICsquareblack": "\u1F18B",
+ "/IJ": "\u0132",
+ "/IUcyrillic": "\u042E",
+ "/Iacute": "\u00CD",
+ "/Iacutesmall": "\uF7ED",
+ "/Ibreve": "\u012C",
+ "/Icaron": "\u01CF",
+ "/Icircle": "\u24BE",
+ "/Icircleblack": "\u1F158",
+ "/Icircumflex": "\u00CE",
+ "/Icircumflexsmall": "\uF7EE",
+ "/Icyr": "\u0418",
+ "/Icyrillic": "\u0406",
+ "/Idblgrave": "\u0208",
+ "/Idieresis": "\u00CF",
+ "/Idieresisacute": "\u1E2E",
+ "/Idieresiscyr": "\u04E4",
+ "/Idieresiscyrillic": "\u04E4",
+ "/Idieresissmall": "\uF7EF",
+ "/Idot": "\u0130",
+ "/Idotaccent": "\u0130",
+ "/Idotbelow": "\u1ECA",
+ "/Iebrevecyr": "\u04D6",
+ "/Iebrevecyrillic": "\u04D6",
+ "/Iecyr": "\u0415",
+ "/Iecyrillic": "\u0415",
+ "/Iegravecyr": "\u0400",
+ "/Ifraktur": "\u2111",
+ "/Igrave": "\u00CC",
+ "/Igravecyr": "\u040D",
+ "/Igravedbl": "\u0208",
+ "/Igravesmall": "\uF7EC",
+ "/Ihoi": "\u1EC8",
+ "/Ihookabove": "\u1EC8",
+ "/Iicyrillic": "\u0418",
+ "/Iinvertedbreve": "\u020A",
+ "/Iishortcyrillic": "\u0419",
+ "/Imacron": "\u012A",
+ "/Imacroncyr": "\u04E2",
+ "/Imacroncyrillic": "\u04E2",
+ "/Imonospace": "\uFF29",
+ "/Iniarmenian": "\u053B",
+ "/Iocyr": "\u0401",
+ "/Iocyrillic": "\u0401",
+ "/Iogonek": "\u012E",
+ "/Iota": "\u0399",
+ "/Iotaacute": "\u1FDB",
+ "/Iotaafrican": "\u0196",
+ "/Iotaasper": "\u1F39",
+ "/Iotaasperacute": "\u1F3D",
+ "/Iotaaspergrave": "\u1F3B",
+ "/Iotaaspertilde": "\u1F3F",
+ "/Iotabreve": "\u1FD8",
+ "/Iotadieresis": "\u03AA",
+ "/Iotagrave": "\u1FDA",
+ "/Iotalenis": "\u1F38",
+ "/Iotalenisacute": "\u1F3C",
+ "/Iotalenisgrave": "\u1F3A",
+ "/Iotalenistilde": "\u1F3E",
+ "/Iotatonos": "\u038A",
+ "/Iotawithmacron": "\u1FD9",
+ "/Iparens": "\u1F118",
+ "/Is": "\uA76C",
+ "/Iscript": "\u2110",
+ "/Ishortcyr": "\u0419",
+ "/Ishortsharptailcyr": "\u048A",
+ "/Ismall": "\uF769",
+ "/Isquare": "\u1F138",
+ "/Isquareblack": "\u1F178",
+ "/Istroke": "\u0197",
+ "/Itilde": "\u0128",
+ "/Itildebelow": "\u1E2C",
+ "/Iukrcyr": "\u0406",
+ "/Izhitsacyr": "\u0474",
+ "/Izhitsacyrillic": "\u0474",
+ "/Izhitsadblgravecyrillic": "\u0476",
+ "/Izhitsagravedblcyr": "\u0476",
+ "/J": "\u004A",
+ "/Jaarmenian": "\u0541",
+ "/Jallajalalouhou": "\uFDFB",
+ "/Jcircle": "\u24BF",
+ "/Jcircleblack": "\u1F159",
+ "/Jcircumflex": "\u0134",
+ "/Jcrossed-tail": "\uA7B2",
+ "/Jecyr": "\u0408",
+ "/Jecyrillic": "\u0408",
+ "/Jheharmenian": "\u054B",
+ "/Jmonospace": "\uFF2A",
+ "/Jparens": "\u1F119",
+ "/Jsmall": "\uF76A",
+ "/Jsquare": "\u1F139",
+ "/Jsquareblack": "\u1F179",
+ "/Jstroke": "\u0248",
+ "/K": "\u004B",
+ "/KBsquare": "\u3385",
+ "/KKsquare": "\u33CD",
+ "/KORONIS": "\u1FBD",
+ "/Kaaleutcyr": "\u051E",
+ "/Kabashkcyr": "\u04A0",
+ "/Kabashkircyrillic": "\u04A0",
+ "/Kacute": "\u1E30",
+ "/Kacyr": "\u041A",
+ "/Kacyrillic": "\u041A",
+ "/Kadescendercyrillic": "\u049A",
+ "/Kahookcyr": "\u04C3",
+ "/Kahookcyrillic": "\u04C3",
+ "/Kaisymbol": "\u03CF",
+ "/Kappa": "\u039A",
+ "/Kastrokecyr": "\u049E",
+ "/Kastrokecyrillic": "\u049E",
+ "/Katailcyr": "\u049A",
+ "/Kaverticalstrokecyr": "\u049C",
+ "/Kaverticalstrokecyrillic": "\u049C",
+ "/Kcaron": "\u01E8",
+ "/Kcedilla": "\u0136",
+ "/Kcircle": "\u24C0",
+ "/Kcircleblack": "\u1F15A",
+ "/Kcommaaccent": "\u0136",
+ "/Kdescender": "\u2C69",
+ "/Kdiagonalstroke": "\uA742",
+ "/Kdotbelow": "\u1E32",
+ "/Keharmenian": "\u0554",
+ "/Kenarmenian": "\u053F",
+ "/Khacyrillic": "\u0425",
+ "/Kheicoptic": "\u03E6",
+ "/Khook": "\u0198",
+ "/Kjecyr": "\u040C",
+ "/Kjecyrillic": "\u040C",
+ "/Klinebelow": "\u1E34",
+ "/Kmonospace": "\uFF2B",
+ "/Kobliquestroke": "\uA7A2",
+ "/Koppa": "\u03DE",
+ "/Koppaarchaic": "\u03D8",
+ "/Koppacyr": "\u0480",
+ "/Koppacyrillic": "\u0480",
+ "/Koppagreek": "\u03DE",
+ "/Kparens": "\u1F11A",
+ "/Ksicyr": "\u046E",
+ "/Ksicyrillic": "\u046E",
+ "/Ksmall": "\uF76B",
+ "/Ksquare": "\u1F13A",
+ "/Ksquareblack": "\u1F17A",
+ "/Kstroke": "\uA740",
+ "/Kstrokediagonalstroke": "\uA744",
+ "/Kturned": "\uA7B0",
+ "/L": "\u004C",
+ "/LJ": "\u01C7",
+ "/LL": "\uF6BF",
+ "/LLwelsh": "\u1EFA",
+ "/LTDfullwidth": "\u32CF",
+ "/Lacute": "\u0139",
+ "/Lambda": "\u039B",
+ "/Lbar": "\u023D",
+ "/Lbelt": "\uA7AD",
+ "/Lbroken": "\uA746",
+ "/Lcaron": "\u013D",
+ "/Lcedilla": "\u013B",
+ "/Lcircle": "\u24C1",
+ "/Lcircleblack": "\u1F15B",
+ "/Lcircumflexbelow": "\u1E3C",
+ "/Lcommaaccent": "\u013B",
+ "/Ldblbar": "\u2C60",
+ "/Ldot": "\u013F",
+ "/Ldotaccent": "\u013F",
+ "/Ldotbelow": "\u1E36",
+ "/Ldotbelowmacron": "\u1E38",
+ "/Lhacyr": "\u0514",
+ "/Liwnarmenian": "\u053C",
+ "/Lj": "\u01C8",
+ "/Ljecyr": "\u0409",
+ "/Ljecyrillic": "\u0409",
+ "/Ljekomicyr": "\u0508",
+ "/Llinebelow": "\u1E3A",
+ "/Lmacrondot": "\u1E38",
+ "/Lmiddletilde": "\u2C62",
+ "/Lmonospace": "\uFF2C",
+ "/Lparens": "\u1F11B",
+ "/Lreversedsans": "\u2143",
+ "/Lscript": "\u2112",
+ "/Lslash": "\u0141",
+ "/Lslashsmall": "\uF6F9",
+ "/Lsmall": "\uF76C",
+ "/Lsquare": "\u1F13B",
+ "/Lsquareblack": "\u1F17B",
+ "/Lstroke": "\uA748",
+ "/Lturned": "\uA780",
+ "/Lturnedsans": "\u2142",
+ "/M": "\u004D",
+ "/MBsquare": "\u3386",
+ "/MVsquare": "\u1F14B",
+ "/Macron": "\uF6D0",
+ "/Macronsmall": "\uF7AF",
+ "/Macute": "\u1E3E",
+ "/Mcircle": "\u24C2",
+ "/Mcircleblack": "\u1F15C",
+ "/Mdot": "\u1E40",
+ "/Mdotaccent": "\u1E40",
+ "/Mdotbelow": "\u1E42",
+ "/Menarmenian": "\u0544",
+ "/Mhook": "\u2C6E",
+ "/Mmonospace": "\uFF2D",
+ "/Mohammad": "\uFDF4",
+ "/Mparens": "\u1F11C",
+ "/Mscript": "\u2133",
+ "/Msmall": "\uF76D",
+ "/Msquare": "\u1F13C",
+ "/Msquareblack": "\u1F17C",
+ "/Mturned": "\u019C",
+ "/Mturnedsmall": "\uA7FA",
+ "/Mu": "\u039C",
+ "/N": "\u004E",
+ "/NJ": "\u01CA",
+ "/Nacute": "\u0143",
+ "/Ncaron": "\u0147",
+ "/Ncedilla": "\u0145",
+ "/Ncircle": "\u24C3",
+ "/Ncircleblack": "\u1F15D",
+ "/Ncircumflexbelow": "\u1E4A",
+ "/Ncommaaccent": "\u0145",
+ "/Ndblstruck": "\u2115",
+ "/Ndescender": "\uA790",
+ "/Ndot": "\u1E44",
+ "/Ndotaccent": "\u1E44",
+ "/Ndotbelow": "\u1E46",
+ "/Ngrave": "\u01F8",
+ "/Nhookleft": "\u019D",
+ "/Nineroman": "\u2168",
+ "/Nj": "\u01CB",
+ "/Njecyr": "\u040A",
+ "/Njecyrillic": "\u040A",
+ "/Njekomicyr": "\u050A",
+ "/Nlinebelow": "\u1E48",
+ "/Nlongrightleg": "\u0220",
+ "/Nmonospace": "\uFF2E",
+ "/Nobliquestroke": "\uA7A4",
+ "/Nowarmenian": "\u0546",
+ "/Nparens": "\u1F11D",
+ "/Nsmall": "\uF76E",
+ "/Nsquare": "\u1F13D",
+ "/Nsquareblack": "\u1F17D",
+ "/Ntilde": "\u00D1",
+ "/Ntildesmall": "\uF7F1",
+ "/Nu": "\u039D",
+ "/O": "\u004F",
+ "/OE": "\u0152",
+ "/OEsmall": "\uF6FA",
+ "/OO": "\uA74E",
+ "/Oacute": "\u00D3",
+ "/Oacutesmall": "\uF7F3",
+ "/Obar": "\u019F",
+ "/Obarcyr": "\u04E8",
+ "/Obardieresiscyr": "\u04EA",
+ "/Obarredcyrillic": "\u04E8",
+ "/Obarreddieresiscyrillic": "\u04EA",
+ "/Obreve": "\u014E",
+ "/Ocaron": "\u01D1",
+ "/Ocenteredtilde": "\u019F",
+ "/Ocircle": "\u24C4",
+ "/Ocircleblack": "\u1F15E",
+ "/Ocircumflex": "\u00D4",
+ "/Ocircumflexacute": "\u1ED0",
+ "/Ocircumflexdotbelow": "\u1ED8",
+ "/Ocircumflexgrave": "\u1ED2",
+ "/Ocircumflexhoi": "\u1ED4",
+ "/Ocircumflexhookabove": "\u1ED4",
+ "/Ocircumflexsmall": "\uF7F4",
+ "/Ocircumflextilde": "\u1ED6",
+ "/Ocyr": "\u041E",
+ "/Ocyrillic": "\u041E",
+ "/Odblacute": "\u0150",
+ "/Odblgrave": "\u020C",
+ "/Odieresis": "\u00D6",
+ "/Odieresiscyr": "\u04E6",
+ "/Odieresiscyrillic": "\u04E6",
+ "/Odieresismacron": "\u022A",
+ "/Odieresissmall": "\uF7F6",
+ "/Odot": "\u022E",
+ "/Odotbelow": "\u1ECC",
+ "/Odotmacron": "\u0230",
+ "/Ogoneksmall": "\uF6FB",
+ "/Ograve": "\u00D2",
+ "/Ogravedbl": "\u020C",
+ "/Ogravesmall": "\uF7F2",
+ "/Oharmenian": "\u0555",
+ "/Ohm": "\u2126",
+ "/Ohoi": "\u1ECE",
+ "/Ohookabove": "\u1ECE",
+ "/Ohorn": "\u01A0",
+ "/Ohornacute": "\u1EDA",
+ "/Ohorndotbelow": "\u1EE2",
+ "/Ohorngrave": "\u1EDC",
+ "/Ohornhoi": "\u1EDE",
+ "/Ohornhookabove": "\u1EDE",
+ "/Ohorntilde": "\u1EE0",
+ "/Ohungarumlaut": "\u0150",
+ "/Oi": "\u01A2",
+ "/Oinvertedbreve": "\u020E",
+ "/Oloop": "\uA74C",
+ "/Omacron": "\u014C",
+ "/Omacronacute": "\u1E52",
+ "/Omacrongrave": "\u1E50",
+ "/Omega": "\u2126",
+ "/Omegaacute": "\u1FFB",
+ "/Omegaasper": "\u1F69",
+ "/Omegaasperacute": "\u1F6D",
+ "/Omegaasperacuteiotasub": "\u1FAD",
+ "/Omegaaspergrave": "\u1F6B",
+ "/Omegaaspergraveiotasub": "\u1FAB",
+ "/Omegaasperiotasub": "\u1FA9",
+ "/Omegaaspertilde": "\u1F6F",
+ "/Omegaaspertildeiotasub": "\u1FAF",
+ "/Omegacyr": "\u0460",
+ "/Omegacyrillic": "\u0460",
+ "/Omegagrave": "\u1FFA",
+ "/Omegagreek": "\u03A9",
+ "/Omegaiotasub": "\u1FFC",
+ "/Omegalenis": "\u1F68",
+ "/Omegalenisacute": "\u1F6C",
+ "/Omegalenisacuteiotasub": "\u1FAC",
+ "/Omegalenisgrave": "\u1F6A",
+ "/Omegalenisgraveiotasub": "\u1FAA",
+ "/Omegalenisiotasub": "\u1FA8",
+ "/Omegalenistilde": "\u1F6E",
+ "/Omegalenistildeiotasub": "\u1FAE",
+ "/Omegaroundcyr": "\u047A",
+ "/Omegaroundcyrillic": "\u047A",
+ "/Omegatitlocyr": "\u047C",
+ "/Omegatitlocyrillic": "\u047C",
+ "/Omegatonos": "\u038F",
+ "/Omicron": "\u039F",
+ "/Omicronacute": "\u1FF9",
+ "/Omicronasper": "\u1F49",
+ "/Omicronasperacute": "\u1F4D",
+ "/Omicronaspergrave": "\u1F4B",
+ "/Omicrongrave": "\u1FF8",
+ "/Omicronlenis": "\u1F48",
+ "/Omicronlenisacute": "\u1F4C",
+ "/Omicronlenisgrave": "\u1F4A",
+ "/Omicrontonos": "\u038C",
+ "/Omonospace": "\uFF2F",
+ "/Oneroman": "\u2160",
+ "/Oogonek": "\u01EA",
+ "/Oogonekmacron": "\u01EC",
+ "/Oopen": "\u0186",
+ "/Oparens": "\u1F11E",
+ "/Oslash": "\u00D8",
+ "/Oslashacute": "\u01FE",
+ "/Oslashsmall": "\uF7F8",
+ "/Osmall": "\uF76F",
+ "/Osquare": "\u1F13E",
+ "/Osquareblack": "\u1F17E",
+ "/Ostroke": "\uA74A",
+ "/Ostrokeacute": "\u01FE",
+ "/Otcyr": "\u047E",
+ "/Otcyrillic": "\u047E",
+ "/Otilde": "\u00D5",
+ "/Otildeacute": "\u1E4C",
+ "/Otildedieresis": "\u1E4E",
+ "/Otildemacron": "\u022C",
+ "/Otildesmall": "\uF7F5",
+ "/Ou": "\u0222",
+ "/P": "\u0050",
+ "/PAsquareblack": "\u1F18C",
+ "/PPVsquare": "\u1F14E",
+ "/Pacute": "\u1E54",
+ "/Palochkacyr": "\u04C0",
+ "/Pcircle": "\u24C5",
+ "/Pcircleblack": "\u1F15F",
+ "/Pcrosssquareblack": "\u1F18A",
+ "/Pdblstruck": "\u2119",
+ "/Pdot": "\u1E56",
+ "/Pdotaccent": "\u1E56",
+ "/Pecyr": "\u041F",
+ "/Pecyrillic": "\u041F",
+ "/Peharmenian": "\u054A",
+ "/Pehookcyr": "\u04A6",
+ "/Pemiddlehookcyrillic": "\u04A6",
+ "/Petailcyr": "\u0524",
+ "/Pflourish": "\uA752",
+ "/Phi": "\u03A6",
+ "/Phook": "\u01A4",
+ "/Pi": "\u03A0",
+ "/Pidblstruck": "\u213F",
+ "/Piwrarmenian": "\u0553",
+ "/Pmonospace": "\uFF30",
+ "/Pparens": "\u1F11F",
+ "/Psi": "\u03A8",
+ "/Psicyr": "\u0470",
+ "/Psicyrillic": "\u0470",
+ "/Psmall": "\uF770",
+ "/Psquare": "\u1F13F",
+ "/Psquareblack": "\u1F17F",
+ "/Pstroke": "\u2C63",
+ "/Pstrokedescender": "\uA750",
+ "/Ptail": "\uA754",
+ "/Q": "\u0051",
+ "/Qacyr": "\u051A",
+ "/QalaUsedAsKoranicStopSign": "\uFDF1",
+ "/Qcircle": "\u24C6",
+ "/Qcircleblack": "\u1F160",
+ "/Qdblstruck": "\u211A",
+ "/Qdiagonalstroke": "\uA758",
+ "/Qmonospace": "\uFF31",
+ "/Qparens": "\u1F120",
+ "/Qrotated": "\u213A",
+ "/Qsmall": "\uF771",
+ "/Qsmallhooktail": "\u024A",
+ "/Qsquare": "\u1F140",
+ "/Qsquareblack": "\u1F180",
+ "/Qstrokedescender": "\uA756",
+ "/R": "\u0052",
+ "/Raarmenian": "\u054C",
+ "/Racute": "\u0154",
+ "/Rasoul": "\uFDF6",
+ "/Rcaron": "\u0158",
+ "/Rcedilla": "\u0156",
+ "/Rcircle": "\u24C7",
+ "/Rcircleblack": "\u1F161",
+ "/Rcommaaccent": "\u0156",
+ "/Rdblgrave": "\u0210",
+ "/Rdblstruck": "\u211D",
+ "/Rdot": "\u1E58",
+ "/Rdotaccent": "\u1E58",
+ "/Rdotbelow": "\u1E5A",
+ "/Rdotbelowmacron": "\u1E5C",
+ "/Reharmenian": "\u0550",
+ "/Reverseddottedsigmalunatesymbol": "\u03FF",
+ "/Reversedzecyr": "\u0510",
+ "/Rfraktur": "\u211C",
+ "/Rgravedbl": "\u0210",
+ "/Rhacyr": "\u0516",
+ "/Rho": "\u03A1",
+ "/Rhoasper": "\u1FEC",
+ "/Ringsmall": "\uF6FC",
+ "/Rinsular": "\uA782",
+ "/Rinvertedbreve": "\u0212",
+ "/Rinvertedsmall": "\u0281",
+ "/Ritaliccircle": "\u1F12C",
+ "/Rlinebelow": "\u1E5E",
+ "/Rmacrondot": "\u1E5C",
+ "/Rmonospace": "\uFF32",
+ "/Robliquestroke": "\uA7A6",
+ "/Rparens": "\u1F121",
+ "/Rrotunda": "\uA75A",
+ "/Rscript": "\u211B",
+ "/Rsmall": "\uF772",
+ "/Rsmallinverted": "\u0281",
+ "/Rsmallinvertedsuperior": "\u02B6",
+ "/Rsquare": "\u1F141",
+ "/Rsquareblack": "\u1F181",
+ "/Rstroke": "\u024C",
+ "/Rsupinvertedmod": "\u02B6",
+ "/Rtail": "\u2C64",
+ "/RubElHizbstart": "\u06DE",
+ "/Rumrotunda": "\uA75C",
+ "/Rumsmall": "\uA776",
+ "/S": "\u0053",
+ "/SAsquareblack": "\u1F18D",
+ "/SDsquare": "\u1F14C",
+ "/SF010000": "\u250C",
+ "/SF020000": "\u2514",
+ "/SF030000": "\u2510",
+ "/SF040000": "\u2518",
+ "/SF050000": "\u253C",
+ "/SF060000": "\u252C",
+ "/SF070000": "\u2534",
+ "/SF080000": "\u251C",
+ "/SF090000": "\u2524",
+ "/SF100000": "\u2500",
+ "/SF110000": "\u2502",
+ "/SF190000": "\u2561",
+ "/SF200000": "\u2562",
+ "/SF210000": "\u2556",
+ "/SF220000": "\u2555",
+ "/SF230000": "\u2563",
+ "/SF240000": "\u2551",
+ "/SF250000": "\u2557",
+ "/SF260000": "\u255D",
+ "/SF270000": "\u255C",
+ "/SF280000": "\u255B",
+ "/SF360000": "\u255E",
+ "/SF370000": "\u255F",
+ "/SF380000": "\u255A",
+ "/SF390000": "\u2554",
+ "/SF400000": "\u2569",
+ "/SF410000": "\u2566",
+ "/SF420000": "\u2560",
+ "/SF430000": "\u2550",
+ "/SF440000": "\u256C",
+ "/SF450000": "\u2567",
+ "/SF460000": "\u2568",
+ "/SF470000": "\u2564",
+ "/SF480000": "\u2565",
+ "/SF490000": "\u2559",
+ "/SF500000": "\u2558",
+ "/SF510000": "\u2552",
+ "/SF520000": "\u2553",
+ "/SF530000": "\u256B",
+ "/SF540000": "\u256A",
+ "/SSsquare": "\u1F14D",
+ "/Sacute": "\u015A",
+ "/Sacutedotaccent": "\u1E64",
+ "/Safha": "\u0603",
+ "/Sajdah": "\u06E9",
+ "/Salam": "\uFDF5",
+ "/Salla": "\uFDF9",
+ "/SallaUsedAsKoranicStopSign": "\uFDF0",
+ "/SallallahouAlayheWasallam": "\uFDFA",
+ "/Saltillo": "\uA78B",
+ "/Sampi": "\u03E0",
+ "/Sampiarchaic": "\u0372",
+ "/Sampigreek": "\u03E0",
+ "/San": "\u03FA",
+ "/Sanah": "\u0601",
+ "/Scaron": "\u0160",
+ "/Scarondot": "\u1E66",
+ "/Scarondotaccent": "\u1E66",
+ "/Scaronsmall": "\uF6FD",
+ "/Scedilla": "\u015E",
+ "/Schwa": "\u018F",
+ "/Schwacyr": "\u04D8",
+ "/Schwacyrillic": "\u04D8",
+ "/Schwadieresiscyr": "\u04DA",
+ "/Schwadieresiscyrillic": "\u04DA",
+ "/Scircle": "\u24C8",
+ "/Scircleblack": "\u1F162",
+ "/Scircumflex": "\u015C",
+ "/Scommaaccent": "\u0218",
+ "/Scriptg": "\uA7AC",
+ "/Sdot": "\u1E60",
+ "/Sdotaccent": "\u1E60",
+ "/Sdotbelow": "\u1E62",
+ "/Sdotbelowdotabove": "\u1E68",
+ "/Sdotbelowdotaccent": "\u1E68",
+ "/Seharmenian": "\u054D",
+ "/Semisoftcyr": "\u048C",
+ "/Sevenroman": "\u2166",
+ "/Shaarmenian": "\u0547",
+ "/Shacyr": "\u0428",
+ "/Shacyrillic": "\u0428",
+ "/Shchacyr": "\u0429",
+ "/Shchacyrillic": "\u0429",
+ "/Sheicoptic": "\u03E2",
+ "/SheneGerishin:hb": "\u059E",
+ "/Shhacyr": "\u04BA",
+ "/Shhacyrillic": "\u04BA",
+ "/Shhatailcyr": "\u0526",
+ "/Shimacoptic": "\u03EC",
+ "/Sho": "\u03F7",
+ "/Sigma": "\u03A3",
+ "/Sigmalunatesymbol": "\u03F9",
+ "/Sigmalunatesymboldotted": "\u03FE",
+ "/Sigmareversedlunatesymbol": "\u03FD",
+ "/Sinsular": "\uA784",
+ "/Sixroman": "\u2165",
+ "/Sjekomicyr": "\u050C",
+ "/Smonospace": "\uFF33",
+ "/Sobliquestroke": "\uA7A8",
+ "/Softcyr": "\u042C",
+ "/Softsigncyrillic": "\u042C",
+ "/Sparens": "\u1F122",
+ "/Sshell": "\u1F12A",
+ "/Ssmall": "\uF773",
+ "/Ssquare": "\u1F142",
+ "/Ssquareblack": "\u1F182",
+ "/Sswashtail": "\u2C7E",
+ "/Stigma": "\u03DA",
+ "/Stigmagreek": "\u03DA",
+ "/T": "\u0054",
+ "/Tau": "\u03A4",
+ "/Tbar": "\u0166",
+ "/Tcaron": "\u0164",
+ "/Tcedilla": "\u0162",
+ "/Tcircle": "\u24C9",
+ "/Tcircleblack": "\u1F163",
+ "/Tcircumflexbelow": "\u1E70",
+ "/Tcommaaccent": "\u0162",
+ "/Tdot": "\u1E6A",
+ "/Tdotaccent": "\u1E6A",
+ "/Tdotbelow": "\u1E6C",
+ "/Tecyr": "\u0422",
+ "/Tecyrillic": "\u0422",
+ "/Tedescendercyrillic": "\u04AC",
+ "/Tenroman": "\u2169",
+ "/Tetailcyr": "\u04AC",
+ "/Tetsecyr": "\u04B4",
+ "/Tetsecyrillic": "\u04B4",
+ "/Theta": "\u0398",
+ "/Thetasymbol": "\u03F4",
+ "/Thook": "\u01AC",
+ "/Thorn": "\u00DE",
+ "/Thornsmall": "\uF7FE",
+ "/Thornstroke": "\uA764",
+ "/Thornstrokedescender": "\uA766",
+ "/Threeroman": "\u2162",
+ "/Tildesmall": "\uF6FE",
+ "/Tinsular": "\uA786",
+ "/Tiwnarmenian": "\u054F",
+ "/Tjekomicyr": "\u050E",
+ "/Tlinebelow": "\u1E6E",
+ "/Tmonospace": "\uFF34",
+ "/Toarmenian": "\u0539",
+ "/Tonefive": "\u01BC",
+ "/Tonesix": "\u0184",
+ "/Tonetwo": "\u01A7",
+ "/Tparens": "\u1F123",
+ "/Tresillo": "\uA72A",
+ "/Tretroflexhook": "\u01AE",
+ "/Tsecyr": "\u0426",
+ "/Tsecyrillic": "\u0426",
+ "/Tshecyr": "\u040B",
+ "/Tshecyrillic": "\u040B",
+ "/Tsmall": "\uF774",
+ "/Tsquare": "\u1F143",
+ "/Tsquareblack": "\u1F183",
+ "/Tturned": "\uA7B1",
+ "/Twelveroman": "\u216B",
+ "/Twithdiagonalstroke": "\u023E",
+ "/Tworoman": "\u2161",
+ "/Tz": "\uA728",
+ "/U": "\u0055",
+ "/Uacute": "\u00DA",
+ "/Uacutedblcyr": "\u04F2",
+ "/Uacutesmall": "\uF7FA",
+ "/Ubar": "\u0244",
+ "/Ubreve": "\u016C",
+ "/Ucaron": "\u01D3",
+ "/Ucircle": "\u24CA",
+ "/Ucircleblack": "\u1F164",
+ "/Ucircumflex": "\u00DB",
+ "/Ucircumflexbelow": "\u1E76",
+ "/Ucircumflexsmall": "\uF7FB",
+ "/Ucyr": "\u0423",
+ "/Ucyrillic": "\u0423",
+ "/Udblacute": "\u0170",
+ "/Udblgrave": "\u0214",
+ "/Udieresis": "\u00DC",
+ "/Udieresisacute": "\u01D7",
+ "/Udieresisbelow": "\u1E72",
+ "/Udieresiscaron": "\u01D9",
+ "/Udieresiscyr": "\u04F0",
+ "/Udieresiscyrillic": "\u04F0",
+ "/Udieresisgrave": "\u01DB",
+ "/Udieresismacron": "\u01D5",
+ "/Udieresissmall": "\uF7FC",
+ "/Udotbelow": "\u1EE4",
+ "/Ugrave": "\u00D9",
+ "/Ugravedbl": "\u0214",
+ "/Ugravesmall": "\uF7F9",
+ "/Uhoi": "\u1EE6",
+ "/Uhookabove": "\u1EE6",
+ "/Uhorn": "\u01AF",
+ "/Uhornacute": "\u1EE8",
+ "/Uhorndotbelow": "\u1EF0",
+ "/Uhorngrave": "\u1EEA",
+ "/Uhornhoi": "\u1EEC",
+ "/Uhornhookabove": "\u1EEC",
+ "/Uhorntilde": "\u1EEE",
+ "/Uhungarumlaut": "\u0170",
+ "/Uhungarumlautcyrillic": "\u04F2",
+ "/Uinvertedbreve": "\u0216",
+ "/Ukcyr": "\u0478",
+ "/Ukcyrillic": "\u0478",
+ "/Umacron": "\u016A",
+ "/Umacroncyr": "\u04EE",
+ "/Umacroncyrillic": "\u04EE",
+ "/Umacrondieresis": "\u1E7A",
+ "/Umonospace": "\uFF35",
+ "/Uogonek": "\u0172",
+ "/Uparens": "\u1F124",
+ "/Upsilon": "\u03A5",
+ "/Upsilon1": "\u03D2",
+ "/Upsilonacute": "\u1FEB",
+ "/Upsilonacutehooksymbol": "\u03D3",
+ "/Upsilonacutehooksymbolgreek": "\u03D3",
+ "/Upsilonadieresishooksymbol": "\u03D4",
+ "/Upsilonafrican": "\u01B1",
+ "/Upsilonasper": "\u1F59",
+ "/Upsilonasperacute": "\u1F5D",
+ "/Upsilonaspergrave": "\u1F5B",
+ "/Upsilonaspertilde": "\u1F5F",
+ "/Upsilonbreve": "\u1FE8",
+ "/Upsilondieresis": "\u03AB",
+ "/Upsilondieresishooksymbolgreek": "\u03D4",
+ "/Upsilongrave": "\u1FEA",
+ "/Upsilonhooksymbol": "\u03D2",
+ "/Upsilontonos": "\u038E",
+ "/Upsilonwithmacron": "\u1FE9",
+ "/Uring": "\u016E",
+ "/Ushortcyr": "\u040E",
+ "/Ushortcyrillic": "\u040E",
+ "/Usmall": "\uF775",
+ "/Usquare": "\u1F144",
+ "/Usquareblack": "\u1F184",
+ "/Ustraightcyr": "\u04AE",
+ "/Ustraightcyrillic": "\u04AE",
+ "/Ustraightstrokecyr": "\u04B0",
+ "/Ustraightstrokecyrillic": "\u04B0",
+ "/Utilde": "\u0168",
+ "/Utildeacute": "\u1E78",
+ "/Utildebelow": "\u1E74",
+ "/V": "\u0056",
+ "/Vcircle": "\u24CB",
+ "/Vcircleblack": "\u1F165",
+ "/Vdiagonalstroke": "\uA75E",
+ "/Vdotbelow": "\u1E7E",
+ "/Vecyr": "\u0412",
+ "/Vecyrillic": "\u0412",
+ "/Vend": "\uA768",
+ "/Vewarmenian": "\u054E",
+ "/Vhook": "\u01B2",
+ "/Visigothicz": "\uA762",
+ "/Vmod": "\u2C7D",
+ "/Vmonospace": "\uFF36",
+ "/Voarmenian": "\u0548",
+ "/Volapukae": "\uA79A",
+ "/Volapukoe": "\uA79C",
+ "/Volapukue": "\uA79E",
+ "/Vparens": "\u1F125",
+ "/Vsmall": "\uF776",
+ "/Vsquare": "\u1F145",
+ "/Vsquareblack": "\u1F185",
+ "/Vtilde": "\u1E7C",
+ "/Vturned": "\u0245",
+ "/Vwelsh": "\u1EFC",
+ "/Vy": "\uA760",
+ "/W": "\u0057",
+ "/WZcircle": "\u1F12E",
+ "/Wacute": "\u1E82",
+ "/Wasallam": "\uFDF8",
+ "/Wcircle": "\u24CC",
+ "/Wcircleblack": "\u1F166",
+ "/Wcircumflex": "\u0174",
+ "/Wdieresis": "\u1E84",
+ "/Wdot": "\u1E86",
+ "/Wdotaccent": "\u1E86",
+ "/Wdotbelow": "\u1E88",
+ "/Wecyr": "\u051C",
+ "/Wgrave": "\u1E80",
+ "/Whook": "\u2C72",
+ "/Wmonospace": "\uFF37",
+ "/Wparens": "\u1F126",
+ "/Wsmall": "\uF777",
+ "/Wsquare": "\u1F146",
+ "/Wsquareblack": "\u1F186",
+ "/Wynn": "\u01F7",
+ "/X": "\u0058",
+ "/Xatailcyr": "\u04B2",
+ "/Xcircle": "\u24CD",
+ "/Xcircleblack": "\u1F167",
+ "/Xdieresis": "\u1E8C",
+ "/Xdot": "\u1E8A",
+ "/Xdotaccent": "\u1E8A",
+ "/Xeharmenian": "\u053D",
+ "/Xi": "\u039E",
+ "/Xmonospace": "\uFF38",
+ "/Xparens": "\u1F127",
+ "/Xsmall": "\uF778",
+ "/Xsquare": "\u1F147",
+ "/Xsquareblack": "\u1F187",
+ "/Y": "\u0059",
+ "/Yacute": "\u00DD",
+ "/Yacutesmall": "\uF7FD",
+ "/Yacyr": "\u042F",
+ "/Yaecyr": "\u0518",
+ "/Yatcyr": "\u0462",
+ "/Yatcyrillic": "\u0462",
+ "/Ycircle": "\u24CE",
+ "/Ycircleblack": "\u1F168",
+ "/Ycircumflex": "\u0176",
+ "/Ydieresis": "\u0178",
+ "/Ydieresissmall": "\uF7FF",
+ "/Ydot": "\u1E8E",
+ "/Ydotaccent": "\u1E8E",
+ "/Ydotbelow": "\u1EF4",
+ "/Yericyrillic": "\u042B",
+ "/Yerudieresiscyrillic": "\u04F8",
+ "/Ygrave": "\u1EF2",
+ "/Yhoi": "\u1EF6",
+ "/Yhook": "\u01B3",
+ "/Yhookabove": "\u1EF6",
+ "/Yiarmenian": "\u0545",
+ "/Yicyrillic": "\u0407",
+ "/Yiwnarmenian": "\u0552",
+ "/Ylongcyr": "\u042B",
+ "/Ylongdieresiscyr": "\u04F8",
+ "/Yloop": "\u1EFE",
+ "/Ymacron": "\u0232",
+ "/Ymonospace": "\uFF39",
+ "/Yogh": "\u021C",
+ "/Yot": "\u037F",
+ "/Yparens": "\u1F128",
+ "/Ysmall": "\uF779",
+ "/Ysquare": "\u1F148",
+ "/Ysquareblack": "\u1F188",
+ "/Ystroke": "\u024E",
+ "/Ytilde": "\u1EF8",
+ "/Yturnedsans": "\u2144",
+ "/Yucyr": "\u042E",
+ "/Yukrcyr": "\u0407",
+ "/Yusbigcyr": "\u046A",
+ "/Yusbigcyrillic": "\u046A",
+ "/Yusbigiotifiedcyr": "\u046C",
+ "/Yusbigiotifiedcyrillic": "\u046C",
+ "/Yuslittlecyr": "\u0466",
+ "/Yuslittlecyrillic": "\u0466",
+ "/Yuslittleiotifiedcyr": "\u0468",
+ "/Yuslittleiotifiedcyrillic": "\u0468",
+ "/Z": "\u005A",
+ "/Zaarmenian": "\u0536",
+ "/Zacute": "\u0179",
+ "/Zcaron": "\u017D",
+ "/Zcaronsmall": "\uF6FF",
+ "/Zcircle": "\u24CF",
+ "/Zcircleblack": "\u1F169",
+ "/Zcircumflex": "\u1E90",
+ "/Zdblstruck": "\u2124",
+ "/Zdescender": "\u2C6B",
+ "/Zdot": "\u017B",
+ "/Zdotaccent": "\u017B",
+ "/Zdotbelow": "\u1E92",
+ "/Zecyr": "\u0417",
+ "/Zecyrillic": "\u0417",
+ "/Zedescendercyrillic": "\u0498",
+ "/Zedieresiscyr": "\u04DE",
+ "/Zedieresiscyrillic": "\u04DE",
+ "/Zeta": "\u0396",
+ "/Zetailcyr": "\u0498",
+ "/Zfraktur": "\u2128",
+ "/Zhearmenian": "\u053A",
+ "/Zhebrevecyr": "\u04C1",
+ "/Zhebrevecyrillic": "\u04C1",
+ "/Zhecyr": "\u0416",
+ "/Zhecyrillic": "\u0416",
+ "/Zhedescendercyrillic": "\u0496",
+ "/Zhedieresiscyr": "\u04DC",
+ "/Zhedieresiscyrillic": "\u04DC",
+ "/Zhetailcyr": "\u0496",
+ "/Zhook": "\u0224",
+ "/Zjekomicyr": "\u0504",
+ "/Zlinebelow": "\u1E94",
+ "/Zmonospace": "\uFF3A",
+ "/Zparens": "\u1F129",
+ "/Zsmall": "\uF77A",
+ "/Zsquare": "\u1F149",
+ "/Zsquareblack": "\u1F189",
+ "/Zstroke": "\u01B5",
+ "/Zswashtail": "\u2C7F",
+ "/a": "\u0061",
+ "/a.inferior": "\u2090",
+ "/aHonRAA": "\u0613",
+ "/aa": "\uA733",
+ "/aabengali": "\u0986",
+ "/aacute": "\u00E1",
+ "/aadeva": "\u0906",
+ "/aagujarati": "\u0A86",
+ "/aagurmukhi": "\u0A06",
+ "/aamatragurmukhi": "\u0A3E",
+ "/aarusquare": "\u3303",
+ "/aavowelsignbengali": "\u09BE",
+ "/aavowelsigndeva": "\u093E",
+ "/aavowelsigngujarati": "\u0ABE",
+ "/abbreviationmarkarmenian": "\u055F",
+ "/abbreviationsigndeva": "\u0970",
+ "/abengali": "\u0985",
+ "/abopomofo": "\u311A",
+ "/abreve": "\u0103",
+ "/abreveacute": "\u1EAF",
+ "/abrevecyr": "\u04D1",
+ "/abrevecyrillic": "\u04D1",
+ "/abrevedotbelow": "\u1EB7",
+ "/abrevegrave": "\u1EB1",
+ "/abrevehoi": "\u1EB3",
+ "/abrevehookabove": "\u1EB3",
+ "/abrevetilde": "\u1EB5",
+ "/absquareblack": "\u1F18E",
+ "/acaron": "\u01CE",
+ "/accountof": "\u2100",
+ "/accurrent": "\u23E6",
+ "/acircle": "\u24D0",
+ "/acirclekatakana": "\u32D0",
+ "/acircumflex": "\u00E2",
+ "/acircumflexacute": "\u1EA5",
+ "/acircumflexdotbelow": "\u1EAD",
+ "/acircumflexgrave": "\u1EA7",
+ "/acircumflexhoi": "\u1EA9",
+ "/acircumflexhookabove": "\u1EA9",
+ "/acircumflextilde": "\u1EAB",
+ "/activatearabicformshaping": "\u206D",
+ "/activatesymmetricswapping": "\u206B",
+ "/acute": "\u00B4",
+ "/acutebelowcmb": "\u0317",
+ "/acutecmb": "\u0301",
+ "/acutecomb": "\u0301",
+ "/acutedblmiddlemod": "\u02F6",
+ "/acutedeva": "\u0954",
+ "/acutelowmod": "\u02CF",
+ "/acutemod": "\u02CA",
+ "/acutetonecmb": "\u0341",
+ "/acyr": "\u0430",
+ "/acyrillic": "\u0430",
+ "/adblgrave": "\u0201",
+ "/addakgurmukhi": "\u0A71",
+ "/addressedsubject": "\u2101",
+ "/adegadegpada": "\uA9CB",
+ "/adegpada": "\uA9CA",
+ "/adeva": "\u0905",
+ "/adieresis": "\u00E4",
+ "/adieresiscyr": "\u04D3",
+ "/adieresiscyrillic": "\u04D3",
+ "/adieresismacron": "\u01DF",
+ "/adishakti": "\u262C",
+ "/admissionTickets": "\u1F39F",
+ "/adot": "\u0227",
+ "/adotbelow": "\u1EA1",
+ "/adotmacron": "\u01E1",
+ "/ae": "\u00E6",
+ "/aeacute": "\u01FD",
+ "/aekorean": "\u3150",
+ "/aemacron": "\u01E3",
+ "/aerialTramway": "\u1F6A1",
+ "/afghani": "\u060B",
+ "/afii00208": "\u2015",
+ "/afii08941": "\u20A4",
+ "/afii10017": "\u0410",
+ "/afii10018": "\u0411",
+ "/afii10019": "\u0412",
+ "/afii10020": "\u0413",
+ "/afii10021": "\u0414",
+ "/afii10022": "\u0415",
+ "/afii10023": "\u0401",
+ "/afii10024": "\u0416",
+ "/afii10025": "\u0417",
+ "/afii10026": "\u0418",
+ "/afii10027": "\u0419",
+ "/afii10028": "\u041A",
+ "/afii10029": "\u041B",
+ "/afii10030": "\u041C",
+ "/afii10031": "\u041D",
+ "/afii10032": "\u041E",
+ "/afii10033": "\u041F",
+ "/afii10034": "\u0420",
+ "/afii10035": "\u0421",
+ "/afii10036": "\u0422",
+ "/afii10037": "\u0423",
+ "/afii10038": "\u0424",
+ "/afii10039": "\u0425",
+ "/afii10040": "\u0426",
+ "/afii10041": "\u0427",
+ "/afii10042": "\u0428",
+ "/afii10043": "\u0429",
+ "/afii10044": "\u042A",
+ "/afii10045": "\u042B",
+ "/afii10046": "\u042C",
+ "/afii10047": "\u042D",
+ "/afii10048": "\u042E",
+ "/afii10049": "\u042F",
+ "/afii10050": "\u0490",
+ "/afii10051": "\u0402",
+ "/afii10052": "\u0403",
+ "/afii10053": "\u0404",
+ "/afii10054": "\u0405",
+ "/afii10055": "\u0406",
+ "/afii10056": "\u0407",
+ "/afii10057": "\u0408",
+ "/afii10058": "\u0409",
+ "/afii10059": "\u040A",
+ "/afii10060": "\u040B",
+ "/afii10061": "\u040C",
+ "/afii10062": "\u040E",
+ "/afii10063": "\uF6C4",
+ "/afii10064": "\uF6C5",
+ "/afii10065": "\u0430",
+ "/afii10066": "\u0431",
+ "/afii10067": "\u0432",
+ "/afii10068": "\u0433",
+ "/afii10069": "\u0434",
+ "/afii10070": "\u0435",
+ "/afii10071": "\u0451",
+ "/afii10072": "\u0436",
+ "/afii10073": "\u0437",
+ "/afii10074": "\u0438",
+ "/afii10075": "\u0439",
+ "/afii10076": "\u043A",
+ "/afii10077": "\u043B",
+ "/afii10078": "\u043C",
+ "/afii10079": "\u043D",
+ "/afii10080": "\u043E",
+ "/afii10081": "\u043F",
+ "/afii10082": "\u0440",
+ "/afii10083": "\u0441",
+ "/afii10084": "\u0442",
+ "/afii10085": "\u0443",
+ "/afii10086": "\u0444",
+ "/afii10087": "\u0445",
+ "/afii10088": "\u0446",
+ "/afii10089": "\u0447",
+ "/afii10090": "\u0448",
+ "/afii10091": "\u0449",
+ "/afii10092": "\u044A",
+ "/afii10093": "\u044B",
+ "/afii10094": "\u044C",
+ "/afii10095": "\u044D",
+ "/afii10096": "\u044E",
+ "/afii10097": "\u044F",
+ "/afii10098": "\u0491",
+ "/afii10099": "\u0452",
+ "/afii10100": "\u0453",
+ "/afii10101": "\u0454",
+ "/afii10102": "\u0455",
+ "/afii10103": "\u0456",
+ "/afii10104": "\u0457",
+ "/afii10105": "\u0458",
+ "/afii10106": "\u0459",
+ "/afii10107": "\u045A",
+ "/afii10108": "\u045B",
+ "/afii10109": "\u045C",
+ "/afii10110": "\u045E",
+ "/afii10145": "\u040F",
+ "/afii10146": "\u0462",
+ "/afii10147": "\u0472",
+ "/afii10148": "\u0474",
+ "/afii10192": "\uF6C6",
+ "/afii10193": "\u045F",
+ "/afii10194": "\u0463",
+ "/afii10195": "\u0473",
+ "/afii10196": "\u0475",
+ "/afii10831": "\uF6C7",
+ "/afii10832": "\uF6C8",
+ "/afii10846": "\u04D9",
+ "/afii299": "\u200E",
+ "/afii300": "\u200F",
+ "/afii301": "\u200D",
+ "/afii57381": "\u066A",
+ "/afii57388": "\u060C",
+ "/afii57392": "\u0660",
+ "/afii57393": "\u0661",
+ "/afii57394": "\u0662",
+ "/afii57395": "\u0663",
+ "/afii57396": "\u0664",
+ "/afii57397": "\u0665",
+ "/afii57398": "\u0666",
+ "/afii57399": "\u0667",
+ "/afii57400": "\u0668",
+ "/afii57401": "\u0669",
+ "/afii57403": "\u061B",
+ "/afii57407": "\u061F",
+ "/afii57409": "\u0621",
+ "/afii57410": "\u0622",
+ "/afii57411": "\u0623",
+ "/afii57412": "\u0624",
+ "/afii57413": "\u0625",
+ "/afii57414": "\u0626",
+ "/afii57415": "\u0627",
+ "/afii57416": "\u0628",
+ "/afii57417": "\u0629",
+ "/afii57418": "\u062A",
+ "/afii57419": "\u062B",
+ "/afii57420": "\u062C",
+ "/afii57421": "\u062D",
+ "/afii57422": "\u062E",
+ "/afii57423": "\u062F",
+ "/afii57424": "\u0630",
+ "/afii57425": "\u0631",
+ "/afii57426": "\u0632",
+ "/afii57427": "\u0633",
+ "/afii57428": "\u0634",
+ "/afii57429": "\u0635",
+ "/afii57430": "\u0636",
+ "/afii57431": "\u0637",
+ "/afii57432": "\u0638",
+ "/afii57433": "\u0639",
+ "/afii57434": "\u063A",
+ "/afii57440": "\u0640",
+ "/afii57441": "\u0641",
+ "/afii57442": "\u0642",
+ "/afii57443": "\u0643",
+ "/afii57444": "\u0644",
+ "/afii57445": "\u0645",
+ "/afii57446": "\u0646",
+ "/afii57448": "\u0648",
+ "/afii57449": "\u0649",
+ "/afii57450": "\u064A",
+ "/afii57451": "\u064B",
+ "/afii57452": "\u064C",
+ "/afii57453": "\u064D",
+ "/afii57454": "\u064E",
+ "/afii57455": "\u064F",
+ "/afii57456": "\u0650",
+ "/afii57457": "\u0651",
+ "/afii57458": "\u0652",
+ "/afii57470": "\u0647",
+ "/afii57505": "\u06A4",
+ "/afii57506": "\u067E",
+ "/afii57507": "\u0686",
+ "/afii57508": "\u0698",
+ "/afii57509": "\u06AF",
+ "/afii57511": "\u0679",
+ "/afii57512": "\u0688",
+ "/afii57513": "\u0691",
+ "/afii57514": "\u06BA",
+ "/afii57519": "\u06D2",
+ "/afii57534": "\u06D5",
+ "/afii57636": "\u20AA",
+ "/afii57645": "\u05BE",
+ "/afii57658": "\u05C3",
+ "/afii57664": "\u05D0",
+ "/afii57665": "\u05D1",
+ "/afii57666": "\u05D2",
+ "/afii57667": "\u05D3",
+ "/afii57668": "\u05D4",
+ "/afii57669": "\u05D5",
+ "/afii57670": "\u05D6",
+ "/afii57671": "\u05D7",
+ "/afii57672": "\u05D8",
+ "/afii57673": "\u05D9",
+ "/afii57674": "\u05DA",
+ "/afii57675": "\u05DB",
+ "/afii57676": "\u05DC",
+ "/afii57677": "\u05DD",
+ "/afii57678": "\u05DE",
+ "/afii57679": "\u05DF",
+ "/afii57680": "\u05E0",
+ "/afii57681": "\u05E1",
+ "/afii57682": "\u05E2",
+ "/afii57683": "\u05E3",
+ "/afii57684": "\u05E4",
+ "/afii57685": "\u05E5",
+ "/afii57686": "\u05E6",
+ "/afii57687": "\u05E7",
+ "/afii57688": "\u05E8",
+ "/afii57689": "\u05E9",
+ "/afii57690": "\u05EA",
+ "/afii57694": "\uFB2A",
+ "/afii57695": "\uFB2B",
+ "/afii57700": "\uFB4B",
+ "/afii57705": "\uFB1F",
+ "/afii57716": "\u05F0",
+ "/afii57717": "\u05F1",
+ "/afii57718": "\u05F2",
+ "/afii57723": "\uFB35",
+ "/afii57793": "\u05B4",
+ "/afii57794": "\u05B5",
+ "/afii57795": "\u05B6",
+ "/afii57796": "\u05BB",
+ "/afii57797": "\u05B8",
+ "/afii57798": "\u05B7",
+ "/afii57799": "\u05B0",
+ "/afii57800": "\u05B2",
+ "/afii57801": "\u05B1",
+ "/afii57802": "\u05B3",
+ "/afii57803": "\u05C2",
+ "/afii57804": "\u05C1",
+ "/afii57806": "\u05B9",
+ "/afii57807": "\u05BC",
+ "/afii57839": "\u05BD",
+ "/afii57841": "\u05BF",
+ "/afii57842": "\u05C0",
+ "/afii57929": "\u02BC",
+ "/afii61248": "\u2105",
+ "/afii61289": "\u2113",
+ "/afii61352": "\u2116",
+ "/afii61573": "\u202C",
+ "/afii61574": "\u202D",
+ "/afii61575": "\u202E",
+ "/afii61664": "\u200C",
+ "/afii63167": "\u066D",
+ "/afii64937": "\u02BD",
+ "/agrave": "\u00E0",
+ "/agravedbl": "\u0201",
+ "/agujarati": "\u0A85",
+ "/agurmukhi": "\u0A05",
+ "/ahiragana": "\u3042",
+ "/ahoi": "\u1EA3",
+ "/ahookabove": "\u1EA3",
+ "/aibengali": "\u0990",
+ "/aibopomofo": "\u311E",
+ "/aideva": "\u0910",
+ "/aiecyr": "\u04D5",
+ "/aiecyrillic": "\u04D5",
+ "/aigujarati": "\u0A90",
+ "/aigurmukhi": "\u0A10",
+ "/aimatragurmukhi": "\u0A48",
+ "/ain.fina": "\uFECA",
+ "/ain.init": "\uFECB",
+ "/ain.init_alefmaksura.fina": "\uFCF7",
+ "/ain.init_jeem.fina": "\uFC29",
+ "/ain.init_jeem.medi": "\uFCBA",
+ "/ain.init_jeem.medi_meem.medi": "\uFDC4",
+ "/ain.init_meem.fina": "\uFC2A",
+ "/ain.init_meem.medi": "\uFCBB",
+ "/ain.init_meem.medi_meem.medi": "\uFD77",
+ "/ain.init_yeh.fina": "\uFCF8",
+ "/ain.isol": "\uFEC9",
+ "/ain.medi": "\uFECC",
+ "/ain.medi_alefmaksura.fina": "\uFD13",
+ "/ain.medi_jeem.medi_meem.fina": "\uFD75",
+ "/ain.medi_meem.medi_alefmaksura.fina": "\uFD78",
+ "/ain.medi_meem.medi_meem.fina": "\uFD76",
+ "/ain.medi_meem.medi_yeh.fina": "\uFDB6",
+ "/ain.medi_yeh.fina": "\uFD14",
+ "/ainThreeDotsDownAbove": "\u075E",
+ "/ainTwoDotsAbove": "\u075D",
+ "/ainTwoDotsVerticallyAbove": "\u075F",
+ "/ainarabic": "\u0639",
+ "/ainfinalarabic": "\uFECA",
+ "/aininitialarabic": "\uFECB",
+ "/ainmedialarabic": "\uFECC",
+ "/ainthreedotsabove": "\u06A0",
+ "/ainvertedbreve": "\u0203",
+ "/airplaneArriving": "\u1F6EC",
+ "/airplaneDeparture": "\u1F6EB",
+ "/aivowelsignbengali": "\u09C8",
+ "/aivowelsigndeva": "\u0948",
+ "/aivowelsigngujarati": "\u0AC8",
+ "/akatakana": "\u30A2",
+ "/akatakanahalfwidth": "\uFF71",
+ "/akorean": "\u314F",
+ "/aktieselskab": "\u214D",
+ "/alarmclock": "\u23F0",
+ "/alef": "\u05D0",
+ "/alef.fina": "\uFE8E",
+ "/alef.init_fathatan.fina": "\uFD3D",
+ "/alef.isol": "\uFE8D",
+ "/alef.medi_fathatan.fina": "\uFD3C",
+ "/alef:hb": "\u05D0",
+ "/alefDigitThreeAbove": "\u0774",
+ "/alefDigitTwoAbove": "\u0773",
+ "/alefLamYehabove": "\u0616",
+ "/alefabove": "\u0670",
+ "/alefarabic": "\u0627",
+ "/alefdageshhebrew": "\uFB30",
+ "/aleffinalarabic": "\uFE8E",
+ "/alefhamza": "\u0623",
+ "/alefhamza.fina": "\uFE84",
+ "/alefhamza.isol": "\uFE83",
+ "/alefhamzaabovearabic": "\u0623",
+ "/alefhamzaabovefinalarabic": "\uFE84",
+ "/alefhamzabelow": "\u0625",
+ "/alefhamzabelow.fina": "\uFE88",
+ "/alefhamzabelow.isol": "\uFE87",
+ "/alefhamzabelowarabic": "\u0625",
+ "/alefhamzabelowfinalarabic": "\uFE88",
+ "/alefhebrew": "\u05D0",
+ "/alefhighhamza": "\u0675",
+ "/aleflamedhebrew": "\uFB4F",
+ "/alefmadda": "\u0622",
+ "/alefmadda.fina": "\uFE82",
+ "/alefmadda.isol": "\uFE81",
+ "/alefmaddaabovearabic": "\u0622",
+ "/alefmaddaabovefinalarabic": "\uFE82",
+ "/alefmaksura": "\u0649",
+ "/alefmaksura.fina": "\uFEF0",
+ "/alefmaksura.init_superscriptalef.fina": "\uFC5D",
+ "/alefmaksura.isol": "\uFEEF",
+ "/alefmaksura.medi_superscriptalef.fina": "\uFC90",
+ "/alefmaksuraarabic": "\u0649",
+ "/alefmaksurafinalarabic": "\uFEF0",
+ "/alefmaksurainitialarabic": "\uFEF3",
+ "/alefmaksuramedialarabic": "\uFEF4",
+ "/alefpatahhebrew": "\uFB2E",
+ "/alefqamatshebrew": "\uFB2F",
+ "/alefwasla": "\u0671",
+ "/alefwasla.fina": "\uFB51",
+ "/alefwasla.isol": "\uFB50",
+ "/alefwavyhamza": "\u0672",
+ "/alefwavyhamzabelow": "\u0673",
+ "/alefwide:hb": "\uFB21",
+ "/alefwithmapiq:hb": "\uFB30",
+ "/alefwithpatah:hb": "\uFB2E",
+ "/alefwithqamats:hb": "\uFB2F",
+ "/alembic": "\u2697",
+ "/aleph": "\u2135",
+ "/alienMonster": "\u1F47E",
+ "/allaroundprofile": "\u232E",
+ "/allequal": "\u224C",
+ "/allianceideographiccircled": "\u32AF",
+ "/allianceideographicparen": "\u323F",
+ "/almostequalorequal": "\u224A",
+ "/alpha": "\u03B1",
+ "/alphaacute": "\u1F71",
+ "/alphaacuteiotasub": "\u1FB4",
+ "/alphaasper": "\u1F01",
+ "/alphaasperacute": "\u1F05",
+ "/alphaasperacuteiotasub": "\u1F85",
+ "/alphaaspergrave": "\u1F03",
+ "/alphaaspergraveiotasub": "\u1F83",
+ "/alphaasperiotasub": "\u1F81",
+ "/alphaaspertilde": "\u1F07",
+ "/alphaaspertildeiotasub": "\u1F87",
+ "/alphabreve": "\u1FB0",
+ "/alphafunc": "\u237A",
+ "/alphagrave": "\u1F70",
+ "/alphagraveiotasub": "\u1FB2",
+ "/alphaiotasub": "\u1FB3",
+ "/alphalenis": "\u1F00",
+ "/alphalenisacute": "\u1F04",
+ "/alphalenisacuteiotasub": "\u1F84",
+ "/alphalenisgrave": "\u1F02",
+ "/alphalenisgraveiotasub": "\u1F82",
+ "/alphalenisiotasub": "\u1F80",
+ "/alphalenistilde": "\u1F06",
+ "/alphalenistildeiotasub": "\u1F86",
+ "/alphatilde": "\u1FB6",
+ "/alphatildeiotasub": "\u1FB7",
+ "/alphatonos": "\u03AC",
+ "/alphaturned": "\u0252",
+ "/alphaunderlinefunc": "\u2376",
+ "/alphawithmacron": "\u1FB1",
+ "/alternateonewayleftwaytraffic": "\u26D5",
+ "/alternative": "\u2387",
+ "/amacron": "\u0101",
+ "/ambulance": "\u1F691",
+ "/americanFootball": "\u1F3C8",
+ "/amfullwidth": "\u33C2",
+ "/amonospace": "\uFF41",
+ "/amountofcheck": "\u2447",
+ "/ampersand": "\u0026",
+ "/ampersandSindhi": "\u06FD",
+ "/ampersandmonospace": "\uFF06",
+ "/ampersandsmall": "\uF726",
+ "/ampersandturned": "\u214B",
+ "/amphora": "\u1F3FA",
+ "/amsquare": "\u33C2",
+ "/anbopomofo": "\u3122",
+ "/anchor": "\u2693",
+ "/ancoradown": "\u2E14",
+ "/ancoraup": "\u2E15",
+ "/andappada": "\uA9C3",
+ "/angbopomofo": "\u3124",
+ "/anger": "\u1F4A2",
+ "/angkhankhuthai": "\u0E5A",
+ "/angle": "\u2220",
+ "/anglearcright": "\u22BE",
+ "/anglebracketleft": "\u3008",
+ "/anglebracketleftvertical": "\uFE3F",
+ "/anglebracketright": "\u3009",
+ "/anglebracketrightvertical": "\uFE40",
+ "/angledottedright": "\u2E16",
+ "/angleleft": "\u2329",
+ "/anglemarkerdottedsubstitutionright": "\u2E01",
+ "/anglemarkersubstitutionright": "\u2E00",
+ "/angleright": "\u232A",
+ "/anglezigzagarrowdownright": "\u237C",
+ "/angryFace": "\u1F620",
+ "/angstrom": "\u212B",
+ "/anguishedFace": "\u1F627",
+ "/ankh": "\u2625",
+ "/anoteleia": "\u0387",
+ "/anpeasquare": "\u3302",
+ "/ant": "\u1F41C",
+ "/antennaBars": "\u1F4F6",
+ "/anticlockwiseDownwardsAndUpwardsOpenCircleArrows": "\u1F504",
+ "/anudattadeva": "\u0952",
+ "/anusvarabengali": "\u0982",
+ "/anusvaradeva": "\u0902",
+ "/anusvaragujarati": "\u0A82",
+ "/ao": "\uA735",
+ "/aogonek": "\u0105",
+ "/aovermfullwidth": "\u33DF",
+ "/apaatosquare": "\u3300",
+ "/aparen": "\u249C",
+ "/aparenthesized": "\u249C",
+ "/apostrophearmenian": "\u055A",
+ "/apostrophedblmod": "\u02EE",
+ "/apostrophemod": "\u02BC",
+ "/apple": "\uF8FF",
+ "/approaches": "\u2250",
+ "/approacheslimit": "\u2250",
+ "/approxequal": "\u2248",
+ "/approxequalorimage": "\u2252",
+ "/approximatelybutnotactuallyequal": "\u2246",
+ "/approximatelyequal": "\u2245",
+ "/approximatelyequalorimage": "\u2252",
+ "/apriltelegraph": "\u32C3",
+ "/aquarius": "\u2652",
+ "/ar:ae": "\u06D5",
+ "/ar:ain": "\u0639",
+ "/ar:alef": "\u0627",
+ "/ar:comma": "\u060C",
+ "/ar:cuberoot": "\u0606",
+ "/ar:decimalseparator": "\u066B",
+ "/ar:e": "\u06D0",
+ "/ar:eight": "\u0668",
+ "/ar:feh": "\u0641",
+ "/ar:five": "\u0665",
+ "/ar:four": "\u0664",
+ "/ar:fourthroot": "\u0607",
+ "/ar:kaf": "\u0643",
+ "/ar:ng": "\u06AD",
+ "/ar:nine": "\u0669",
+ "/ar:numbersign": "\u0600",
+ "/ar:oe": "\u06C6",
+ "/ar:one": "\u0661",
+ "/ar:peh": "\u067E",
+ "/ar:percent": "\u066A",
+ "/ar:perthousand": "\u060A",
+ "/ar:question": "\u061F",
+ "/ar:reh": "\u0631",
+ "/ar:semicolon": "\u061B",
+ "/ar:seven": "\u0667",
+ "/ar:shadda": "\u0651",
+ "/ar:six": "\u0666",
+ "/ar:sukun": "\u0652",
+ "/ar:three": "\u0663",
+ "/ar:two": "\u0662",
+ "/ar:u": "\u06C7",
+ "/ar:ve": "\u06CB",
+ "/ar:yu": "\u06C8",
+ "/ar:zero": "\u0660",
+ "/araeaekorean": "\u318E",
+ "/araeakorean": "\u318D",
+ "/arc": "\u2312",
+ "/archaicmepigraphic": "\uA7FF",
+ "/aries": "\u2648",
+ "/arighthalfring": "\u1E9A",
+ "/aring": "\u00E5",
+ "/aringacute": "\u01FB",
+ "/aringbelow": "\u1E01",
+ "/armn:Ayb": "\u0531",
+ "/armn:Ben": "\u0532",
+ "/armn:Ca": "\u053E",
+ "/armn:Cha": "\u0549",
+ "/armn:Cheh": "\u0543",
+ "/armn:Co": "\u0551",
+ "/armn:DRAMSIGN": "\u058F",
+ "/armn:Da": "\u0534",
+ "/armn:Ech": "\u0535",
+ "/armn:Eh": "\u0537",
+ "/armn:Et": "\u0538",
+ "/armn:Feh": "\u0556",
+ "/armn:Ghad": "\u0542",
+ "/armn:Gim": "\u0533",
+ "/armn:Ho": "\u0540",
+ "/armn:Ini": "\u053B",
+ "/armn:Ja": "\u0541",
+ "/armn:Jheh": "\u054B",
+ "/armn:Keh": "\u0554",
+ "/armn:Ken": "\u053F",
+ "/armn:Liwn": "\u053C",
+ "/armn:Men": "\u0544",
+ "/armn:Now": "\u0546",
+ "/armn:Oh": "\u0555",
+ "/armn:Peh": "\u054A",
+ "/armn:Piwr": "\u0553",
+ "/armn:Ra": "\u054C",
+ "/armn:Reh": "\u0550",
+ "/armn:Seh": "\u054D",
+ "/armn:Sha": "\u0547",
+ "/armn:Tiwn": "\u054F",
+ "/armn:To": "\u0539",
+ "/armn:Vew": "\u054E",
+ "/armn:Vo": "\u0548",
+ "/armn:Xeh": "\u053D",
+ "/armn:Yi": "\u0545",
+ "/armn:Yiwn": "\u0552",
+ "/armn:Za": "\u0536",
+ "/armn:Zhe": "\u053A",
+ "/armn:abbreviationmark": "\u055F",
+ "/armn:apostrophe": "\u055A",
+ "/armn:ayb": "\u0561",
+ "/armn:ben": "\u0562",
+ "/armn:ca": "\u056E",
+ "/armn:cha": "\u0579",
+ "/armn:cheh": "\u0573",
+ "/armn:co": "\u0581",
+ "/armn:comma": "\u055D",
+ "/armn:da": "\u0564",
+ "/armn:ech": "\u0565",
+ "/armn:ech_yiwn": "\u0587",
+ "/armn:eh": "\u0567",
+ "/armn:emphasismark": "\u055B",
+ "/armn:et": "\u0568",
+ "/armn:exclam": "\u055C",
+ "/armn:feh": "\u0586",
+ "/armn:ghad": "\u0572",
+ "/armn:gim": "\u0563",
+ "/armn:ho": "\u0570",
+ "/armn:hyphen": "\u058A",
+ "/armn:ini": "\u056B",
+ "/armn:ja": "\u0571",
+ "/armn:jheh": "\u057B",
+ "/armn:keh": "\u0584",
+ "/armn:ken": "\u056F",
+ "/armn:leftfacingeternitysign": "\u058E",
+ "/armn:liwn": "\u056C",
+ "/armn:men": "\u0574",
+ "/armn:men_ech": "\uFB14",
+ "/armn:men_ini": "\uFB15",
+ "/armn:men_now": "\uFB13",
+ "/armn:men_xeh": "\uFB17",
+ "/armn:now": "\u0576",
+ "/armn:oh": "\u0585",
+ "/armn:peh": "\u057A",
+ "/armn:period": "\u0589",
+ "/armn:piwr": "\u0583",
+ "/armn:question": "\u055E",
+ "/armn:ra": "\u057C",
+ "/armn:reh": "\u0580",
+ "/armn:rightfacingeternitysign": "\u058D",
+ "/armn:ringhalfleft": "\u0559",
+ "/armn:seh": "\u057D",
+ "/armn:sha": "\u0577",
+ "/armn:tiwn": "\u057F",
+ "/armn:to": "\u0569",
+ "/armn:vew": "\u057E",
+ "/armn:vew_now": "\uFB16",
+ "/armn:vo": "\u0578",
+ "/armn:xeh": "\u056D",
+ "/armn:yi": "\u0575",
+ "/armn:yiwn": "\u0582",
+ "/armn:za": "\u0566",
+ "/armn:zhe": "\u056A",
+ "/arrowNE": "\u2197",
+ "/arrowNW": "\u2196",
+ "/arrowSE": "\u2198",
+ "/arrowSW": "\u2199",
+ "/arrowanticlockwiseopencircle": "\u21BA",
+ "/arrowanticlockwisesemicircle": "\u21B6",
+ "/arrowboth": "\u2194",
+ "/arrowclockwiseopencircle": "\u21BB",
+ "/arrowclockwisesemicircle": "\u21B7",
+ "/arrowdashdown": "\u21E3",
+ "/arrowdashleft": "\u21E0",
+ "/arrowdashright": "\u21E2",
+ "/arrowdashup": "\u21E1",
+ "/arrowdblboth": "\u21D4",
+ "/arrowdbldown": "\u21D3",
+ "/arrowdblleft": "\u21D0",
+ "/arrowdblright": "\u21D2",
+ "/arrowdblup": "\u21D1",
+ "/arrowdown": "\u2193",
+ "/arrowdowndashed": "\u21E3",
+ "/arrowdownfrombar": "\u21A7",
+ "/arrowdownleft": "\u2199",
+ "/arrowdownright": "\u2198",
+ "/arrowdowntwoheaded": "\u21A1",
+ "/arrowdownwhite": "\u21E9",
+ "/arrowdownzigzag": "\u21AF",
+ "/arrowheaddown": "\u2304",
+ "/arrowheaddownlowmod": "\u02EF",
+ "/arrowheaddownmod": "\u02C5",
+ "/arrowheadleftlowmod": "\u02F1",
+ "/arrowheadleftmod": "\u02C2",
+ "/arrowheadrightlowmod": "\u02F2",
+ "/arrowheadrightmod": "\u02C3",
+ "/arrowheadtwobarsuphorizontal": "\u2324",
+ "/arrowheadup": "\u2303",
+ "/arrowheaduplowmod": "\u02F0",
+ "/arrowheadupmod": "\u02C4",
+ "/arrowhorizex": "\uF8E7",
+ "/arrowleft": "\u2190",
+ "/arrowleftdashed": "\u21E0",
+ "/arrowleftdbl": "\u21D0",
+ "/arrowleftdblstroke": "\u21CD",
+ "/arrowleftdowncorner": "\u21B5",
+ "/arrowleftdowntip": "\u21B2",
+ "/arrowleftfrombar": "\u21A4",
+ "/arrowlefthook": "\u21A9",
+ "/arrowleftloop": "\u21AB",
+ "/arrowleftlowmod": "\u02FF",
+ "/arrowleftoverright": "\u21C6",
+ "/arrowleftoverrighttobar": "\u21B9",
+ "/arrowleftright": "\u2194",
+ "/arrowleftrightstroke": "\u21AE",
+ "/arrowleftrightwave": "\u21AD",
+ "/arrowleftsquiggle": "\u21DC",
+ "/arrowleftstroke": "\u219A",
+ "/arrowlefttail": "\u21A2",
+ "/arrowlefttobar": "\u21E4",
+ "/arrowlefttwoheaded": "\u219E",
+ "/arrowleftuptip": "\u21B0",
+ "/arrowleftwave": "\u219C",
+ "/arrowleftwhite": "\u21E6",
+ "/arrowlongNWtobar": "\u21B8",
+ "/arrowright": "\u2192",
+ "/arrowrightdashed": "\u21E2",
+ "/arrowrightdblstroke": "\u21CF",
+ "/arrowrightdowncorner": "\u21B4",
+ "/arrowrightdowntip": "\u21B3",
+ "/arrowrightfrombar": "\u21A6",
+ "/arrowrightheavy": "\u279E",
+ "/arrowrighthook": "\u21AA",
+ "/arrowrightloop": "\u21AC",
+ "/arrowrightoverleft": "\u21C4",
+ "/arrowrightsmallcircle": "\u21F4",
+ "/arrowrightsquiggle": "\u21DD",
+ "/arrowrightstroke": "\u219B",
+ "/arrowrighttail": "\u21A3",
+ "/arrowrighttobar": "\u21E5",
+ "/arrowrighttwoheaded": "\u21A0",
+ "/arrowrightwave": "\u219D",
+ "/arrowrightwhite": "\u21E8",
+ "/arrowspaireddown": "\u21CA",
+ "/arrowspairedleft": "\u21C7",
+ "/arrowspairedright": "\u21C9",
+ "/arrowspairedup": "\u21C8",
+ "/arrowtableft": "\u21E4",
+ "/arrowtabright": "\u21E5",
+ "/arrowup": "\u2191",
+ "/arrowupdashed": "\u21E1",
+ "/arrowupdn": "\u2195",
+ "/arrowupdnbse": "\u21A8",
+ "/arrowupdown": "\u2195",
+ "/arrowupdownbase": "\u21A8",
+ "/arrowupdownwithbase": "\u21A8",
+ "/arrowupfrombar": "\u21A5",
+ "/arrowupleft": "\u2196",
+ "/arrowupleftofdown": "\u21C5",
+ "/arrowupright": "\u2197",
+ "/arrowuprighttip": "\u21B1",
+ "/arrowuptwoheaded": "\u219F",
+ "/arrowupwhite": "\u21E7",
+ "/arrowvertex": "\uF8E6",
+ "/articulatedLorry": "\u1F69B",
+ "/artistPalette": "\u1F3A8",
+ "/aruhuasquare": "\u3301",
+ "/asciicircum": "\u005E",
+ "/asciicircummonospace": "\uFF3E",
+ "/asciitilde": "\u007E",
+ "/asciitildemonospace": "\uFF5E",
+ "/ascript": "\u0251",
+ "/ascriptturned": "\u0252",
+ "/asmallhiragana": "\u3041",
+ "/asmallkatakana": "\u30A1",
+ "/asmallkatakanahalfwidth": "\uFF67",
+ "/asper": "\u1FFE",
+ "/asperacute": "\u1FDE",
+ "/aspergrave": "\u1FDD",
+ "/aspertilde": "\u1FDF",
+ "/assertion": "\u22A6",
+ "/asterisk": "\u002A",
+ "/asteriskaltonearabic": "\u066D",
+ "/asteriskarabic": "\u066D",
+ "/asteriskmath": "\u2217",
+ "/asteriskmonospace": "\uFF0A",
+ "/asterisksmall": "\uFE61",
+ "/asterism": "\u2042",
+ "/astonishedFace": "\u1F632",
+ "/astroke": "\u2C65",
+ "/astronomicaluranus": "\u26E2",
+ "/asuperior": "\uF6E9",
+ "/asympticallyequal": "\u2243",
+ "/asymptoticallyequal": "\u2243",
+ "/at": "\u0040",
+ "/athleticShoe": "\u1F45F",
+ "/atilde": "\u00E3",
+ "/atmonospace": "\uFF20",
+ "/atnachHafukh:hb": "\u05A2",
+ "/atom": "\u269B",
+ "/atsmall": "\uFE6B",
+ "/attentionideographiccircled": "\u329F",
+ "/aturned": "\u0250",
+ "/au": "\uA737",
+ "/aubengali": "\u0994",
+ "/aubergine": "\u1F346",
+ "/aubopomofo": "\u3120",
+ "/audeva": "\u0914",
+ "/aufullwidth": "\u3373",
+ "/augujarati": "\u0A94",
+ "/augurmukhi": "\u0A14",
+ "/augusttelegraph": "\u32C7",
+ "/aulengthmarkbengali": "\u09D7",
+ "/aumatragurmukhi": "\u0A4C",
+ "/austral": "\u20B3",
+ "/automatedTellerMachine": "\u1F3E7",
+ "/automobile": "\u1F697",
+ "/auvowelsignbengali": "\u09CC",
+ "/auvowelsigndeva": "\u094C",
+ "/auvowelsigngujarati": "\u0ACC",
+ "/av": "\uA739",
+ "/avagrahadeva": "\u093D",
+ "/avhorizontalbar": "\uA73B",
+ "/ay": "\uA73D",
+ "/aybarmenian": "\u0561",
+ "/ayin": "\u05E2",
+ "/ayin:hb": "\u05E2",
+ "/ayinalt:hb": "\uFB20",
+ "/ayinaltonehebrew": "\uFB20",
+ "/ayinhebrew": "\u05E2",
+ "/azla:hb": "\u059C",
+ "/b": "\u0062",
+ "/baarerusquare": "\u332D",
+ "/babengali": "\u09AC",
+ "/babyAngel": "\u1F47C",
+ "/babyBottle": "\u1F37C",
+ "/babyChick": "\u1F424",
+ "/backLeftwardsArrowAbove": "\u1F519",
+ "/backOfEnvelope": "\u1F582",
+ "/backslash": "\u005C",
+ "/backslashbarfunc": "\u2340",
+ "/backslashdbl": "\u244A",
+ "/backslashmonospace": "\uFF3C",
+ "/bactrianCamel": "\u1F42B",
+ "/badeva": "\u092C",
+ "/badmintonRacquetAndShuttlecock": "\u1F3F8",
+ "/bagdelimitersshapeleft": "\u27C5",
+ "/bagdelimitersshaperight": "\u27C6",
+ "/baggageClaim": "\u1F6C4",
+ "/bagujarati": "\u0AAC",
+ "/bagurmukhi": "\u0A2C",
+ "/bahiragana": "\u3070",
+ "/bahtthai": "\u0E3F",
+ "/bakatakana": "\u30D0",
+ "/balloon": "\u1F388",
+ "/ballotBoldScriptX": "\u1F5F6",
+ "/ballotBoxBallot": "\u1F5F3",
+ "/ballotBoxBoldCheck": "\u1F5F9",
+ "/ballotBoxBoldScriptX": "\u1F5F7",
+ "/ballotBoxScriptX": "\u1F5F5",
+ "/ballotScriptX": "\u1F5F4",
+ "/bamurda": "\uA9A8",
+ "/banana": "\u1F34C",
+ "/bank": "\u1F3E6",
+ "/banknoteDollarSign": "\u1F4B5",
+ "/banknoteEuroSign": "\u1F4B6",
+ "/banknotePoundSign": "\u1F4B7",
+ "/banknoteYenSign": "\u1F4B4",
+ "/bar": "\u007C",
+ "/barChart": "\u1F4CA",
+ "/barberPole": "\u1F488",
+ "/barfullwidth": "\u3374",
+ "/barmonospace": "\uFF5C",
+ "/barquillverticalleft": "\u2E20",
+ "/barquillverticalright": "\u2E21",
+ "/baseball": "\u26BE",
+ "/basketballAndHoop": "\u1F3C0",
+ "/bath": "\u1F6C0",
+ "/bathtub": "\u1F6C1",
+ "/battery": "\u1F50B",
+ "/bbopomofo": "\u3105",
+ "/bcircle": "\u24D1",
+ "/bdot": "\u1E03",
+ "/bdotaccent": "\u1E03",
+ "/bdotbelow": "\u1E05",
+ "/beachUmbrella": "\u1F3D6",
+ "/beamedAscendingMusicalNotes": "\u1F39C",
+ "/beamedDescendingMusicalNotes": "\u1F39D",
+ "/beamedeighthnotes": "\u266B",
+ "/beamedsixteenthnotes": "\u266C",
+ "/beamfunc": "\u2336",
+ "/bearFace": "\u1F43B",
+ "/beatingHeart": "\u1F493",
+ "/because": "\u2235",
+ "/becyr": "\u0431",
+ "/becyrillic": "\u0431",
+ "/bed": "\u1F6CF",
+ "/beeh": "\u067B",
+ "/beeh.fina": "\uFB53",
+ "/beeh.init": "\uFB54",
+ "/beeh.isol": "\uFB52",
+ "/beeh.medi": "\uFB55",
+ "/beerMug": "\u1F37A",
+ "/beetasquare": "\u333C",
+ "/beh": "\u0628",
+ "/beh.fina": "\uFE90",
+ "/beh.init": "\uFE91",
+ "/beh.init_alefmaksura.fina": "\uFC09",
+ "/beh.init_hah.fina": "\uFC06",
+ "/beh.init_hah.medi": "\uFC9D",
+ "/beh.init_heh.medi": "\uFCA0",
+ "/beh.init_jeem.fina": "\uFC05",
+ "/beh.init_jeem.medi": "\uFC9C",
+ "/beh.init_khah.fina": "\uFC07",
+ "/beh.init_khah.medi": "\uFC9E",
+ "/beh.init_meem.fina": "\uFC08",
+ "/beh.init_meem.medi": "\uFC9F",
+ "/beh.init_yeh.fina": "\uFC0A",
+ "/beh.isol": "\uFE8F",
+ "/beh.medi": "\uFE92",
+ "/beh.medi_alefmaksura.fina": "\uFC6E",
+ "/beh.medi_hah.medi_yeh.fina": "\uFDC2",
+ "/beh.medi_heh.medi": "\uFCE2",
+ "/beh.medi_khah.medi_yeh.fina": "\uFD9E",
+ "/beh.medi_meem.fina": "\uFC6C",
+ "/beh.medi_meem.medi": "\uFCE1",
+ "/beh.medi_noon.fina": "\uFC6D",
+ "/beh.medi_reh.fina": "\uFC6A",
+ "/beh.medi_yeh.fina": "\uFC6F",
+ "/beh.medi_zain.fina": "\uFC6B",
+ "/behDotBelowThreeDotsAbove": "\u0751",
+ "/behInvertedSmallVBelow": "\u0755",
+ "/behSmallV": "\u0756",
+ "/behThreeDotsHorizontallyBelow": "\u0750",
+ "/behThreeDotsUpBelow": "\u0752",
+ "/behThreeDotsUpBelowTwoDotsAbove": "\u0753",
+ "/behTwoDotsBelowDotAbove": "\u0754",
+ "/beharabic": "\u0628",
+ "/beheh": "\u0680",
+ "/beheh.fina": "\uFB5B",
+ "/beheh.init": "\uFB5C",
+ "/beheh.isol": "\uFB5A",
+ "/beheh.medi": "\uFB5D",
+ "/behfinalarabic": "\uFE90",
+ "/behinitialarabic": "\uFE91",
+ "/behiragana": "\u3079",
+ "/behmedialarabic": "\uFE92",
+ "/behmeeminitialarabic": "\uFC9F",
+ "/behmeemisolatedarabic": "\uFC08",
+ "/behnoonfinalarabic": "\uFC6D",
+ "/bekatakana": "\u30D9",
+ "/bellCancellationStroke": "\u1F515",
+ "/bellhopBell": "\u1F6CE",
+ "/beltbuckle": "\u2444",
+ "/benarmenian": "\u0562",
+ "/beng:a": "\u0985",
+ "/beng:aa": "\u0986",
+ "/beng:aasign": "\u09BE",
+ "/beng:abbreviationsign": "\u09FD",
+ "/beng:ai": "\u0990",
+ "/beng:aisign": "\u09C8",
+ "/beng:anji": "\u0980",
+ "/beng:anusvara": "\u0982",
+ "/beng:au": "\u0994",
+ "/beng:aulengthmark": "\u09D7",
+ "/beng:ausign": "\u09CC",
+ "/beng:avagraha": "\u09BD",
+ "/beng:ba": "\u09AC",
+ "/beng:bha": "\u09AD",
+ "/beng:ca": "\u099A",
+ "/beng:candrabindu": "\u0981",
+ "/beng:cha": "\u099B",
+ "/beng:currencyoneless": "\u09F8",
+ "/beng:da": "\u09A6",
+ "/beng:dda": "\u09A1",
+ "/beng:ddha": "\u09A2",
+ "/beng:dha": "\u09A7",
+ "/beng:e": "\u098F",
+ "/beng:eight": "\u09EE",
+ "/beng:esign": "\u09C7",
+ "/beng:five": "\u09EB",
+ "/beng:four": "\u09EA",
+ "/beng:fourcurrencynumerator": "\u09F7",
+ "/beng:ga": "\u0997",
+ "/beng:gandamark": "\u09FB",
+ "/beng:gha": "\u0998",
+ "/beng:ha": "\u09B9",
+ "/beng:i": "\u0987",
+ "/beng:ii": "\u0988",
+ "/beng:iisign": "\u09C0",
+ "/beng:isign": "\u09BF",
+ "/beng:isshar": "\u09FA",
+ "/beng:ja": "\u099C",
+ "/beng:jha": "\u099D",
+ "/beng:ka": "\u0995",
+ "/beng:kha": "\u0996",
+ "/beng:khandata": "\u09CE",
+ "/beng:la": "\u09B2",
+ "/beng:llvocal": "\u09E1",
+ "/beng:llvocalsign": "\u09E3",
+ "/beng:lvocal": "\u098C",
+ "/beng:lvocalsign": "\u09E2",
+ "/beng:ma": "\u09AE",
+ "/beng:na": "\u09A8",
+ "/beng:nga": "\u0999",
+ "/beng:nine": "\u09EF",
+ "/beng:nna": "\u09A3",
+ "/beng:nukta": "\u09BC",
+ "/beng:nya": "\u099E",
+ "/beng:o": "\u0993",
+ "/beng:one": "\u09E7",
+ "/beng:onecurrencynumerator": "\u09F4",
+ "/beng:osign": "\u09CB",
+ "/beng:pa": "\u09AA",
+ "/beng:pha": "\u09AB",
+ "/beng:ra": "\u09B0",
+ "/beng:ralowdiagonal": "\u09F1",
+ "/beng:ramiddiagonal": "\u09F0",
+ "/beng:rha": "\u09DD",
+ "/beng:rra": "\u09DC",
+ "/beng:rrvocal": "\u09E0",
+ "/beng:rrvocalsign": "\u09C4",
+ "/beng:rupee": "\u09F3",
+ "/beng:rupeemark": "\u09F2",
+ "/beng:rvocal": "\u098B",
+ "/beng:rvocalsign": "\u09C3",
+ "/beng:sa": "\u09B8",
+ "/beng:seven": "\u09ED",
+ "/beng:sha": "\u09B6",
+ "/beng:six": "\u09EC",
+ "/beng:sixteencurrencydenominator": "\u09F9",
+ "/beng:ssa": "\u09B7",
+ "/beng:ta": "\u09A4",
+ "/beng:tha": "\u09A5",
+ "/beng:three": "\u09E9",
+ "/beng:threecurrencynumerator": "\u09F6",
+ "/beng:tta": "\u099F",
+ "/beng:ttha": "\u09A0",
+ "/beng:two": "\u09E8",
+ "/beng:twocurrencynumerator": "\u09F5",
+ "/beng:u": "\u0989",
+ "/beng:usign": "\u09C1",
+ "/beng:uu": "\u098A",
+ "/beng:uusign": "\u09C2",
+ "/beng:vedicanusvara": "\u09FC",
+ "/beng:virama": "\u09CD",
+ "/beng:visarga": "\u0983",
+ "/beng:ya": "\u09AF",
+ "/beng:yya": "\u09DF",
+ "/beng:zero": "\u09E6",
+ "/bentoBox": "\u1F371",
+ "/benzenering": "\u232C",
+ "/benzeneringcircle": "\u23E3",
+ "/bet": "\u05D1",
+ "/bet:hb": "\u05D1",
+ "/beta": "\u03B2",
+ "/betasymbol": "\u03D0",
+ "/betasymbolgreek": "\u03D0",
+ "/betdagesh": "\uFB31",
+ "/betdageshhebrew": "\uFB31",
+ "/bethebrew": "\u05D1",
+ "/betrafehebrew": "\uFB4C",
+ "/between": "\u226C",
+ "/betwithdagesh:hb": "\uFB31",
+ "/betwithrafe:hb": "\uFB4C",
+ "/bflourish": "\uA797",
+ "/bhabengali": "\u09AD",
+ "/bhadeva": "\u092D",
+ "/bhagujarati": "\u0AAD",
+ "/bhagurmukhi": "\u0A2D",
+ "/bhook": "\u0253",
+ "/bicycle": "\u1F6B2",
+ "/bicyclist": "\u1F6B4",
+ "/bihiragana": "\u3073",
+ "/bikatakana": "\u30D3",
+ "/bikini": "\u1F459",
+ "/bilabialclick": "\u0298",
+ "/billiards": "\u1F3B1",
+ "/bindigurmukhi": "\u0A02",
+ "/biohazard": "\u2623",
+ "/bird": "\u1F426",
+ "/birthdayCake": "\u1F382",
+ "/birusquare": "\u3331",
+ "/bishopblack": "\u265D",
+ "/bishopwhite": "\u2657",
+ "/bitcoin": "\u20BF",
+ "/blackDownPointingBackhandIndex": "\u1F5A3",
+ "/blackDroplet": "\u1F322",
+ "/blackFolder": "\u1F5BF",
+ "/blackHardShellFloppyDisk": "\u1F5AA",
+ "/blackHeart": "\u1F5A4",
+ "/blackLeftPointingBackhandIndex": "\u1F59C",
+ "/blackPennant": "\u1F3F2",
+ "/blackPushpin": "\u1F588",
+ "/blackRightPointingBackhandIndex": "\u1F59D",
+ "/blackRosette": "\u1F3F6",
+ "/blackSkullAndCrossbones": "\u1F571",
+ "/blackSquareButton": "\u1F532",
+ "/blackTouchtoneTelephone": "\u1F57F",
+ "/blackUpPointingBackhandIndex": "\u1F5A2",
+ "/blackcircle": "\u25CF",
+ "/blackcircleforrecord": "\u23FA",
+ "/blackdiamond": "\u25C6",
+ "/blackdownpointingtriangle": "\u25BC",
+ "/blackforstopsquare": "\u23F9",
+ "/blackleftpointingpointer": "\u25C4",
+ "/blackleftpointingtriangle": "\u25C0",
+ "/blacklenticularbracketleft": "\u3010",
+ "/blacklenticularbracketleftvertical": "\uFE3B",
+ "/blacklenticularbracketright": "\u3011",
+ "/blacklenticularbracketrightvertical": "\uFE3C",
+ "/blacklowerlefttriangle": "\u25E3",
+ "/blacklowerrighttriangle": "\u25E2",
+ "/blackmediumpointingtriangledown": "\u23F7",
+ "/blackmediumpointingtriangleleft": "\u23F4",
+ "/blackmediumpointingtriangleright": "\u23F5",
+ "/blackmediumpointingtriangleup": "\u23F6",
+ "/blackpointingdoubletrianglebarverticalleft": "\u23EE",
+ "/blackpointingdoubletrianglebarverticalright": "\u23ED",
+ "/blackpointingdoubletriangledown": "\u23EC",
+ "/blackpointingdoubletriangleleft": "\u23EA",
+ "/blackpointingdoubletriangleright": "\u23E9",
+ "/blackpointingdoubletriangleup": "\u23EB",
+ "/blackpointingtriangledoublebarverticalright": "\u23EF",
+ "/blackrectangle": "\u25AC",
+ "/blackrightpointingpointer": "\u25BA",
+ "/blackrightpointingtriangle": "\u25B6",
+ "/blacksmallsquare": "\u25AA",
+ "/blacksmilingface": "\u263B",
+ "/blacksquare": "\u25A0",
+ "/blackstar": "\u2605",
+ "/blackupperlefttriangle": "\u25E4",
+ "/blackupperrighttriangle": "\u25E5",
+ "/blackuppointingsmalltriangle": "\u25B4",
+ "/blackuppointingtriangle": "\u25B2",
+ "/blackwardsbulletleft": "\u204C",
+ "/blackwardsbulletright": "\u204D",
+ "/blank": "\u2423",
+ "/blinebelow": "\u1E07",
+ "/block": "\u2588",
+ "/blossom": "\u1F33C",
+ "/blowfish": "\u1F421",
+ "/blueBook": "\u1F4D8",
+ "/blueHeart": "\u1F499",
+ "/bmonospace": "\uFF42",
+ "/boar": "\u1F417",
+ "/board": "\u2328",
+ "/bobaimaithai": "\u0E1A",
+ "/bohiragana": "\u307C",
+ "/bokatakana": "\u30DC",
+ "/bomb": "\u1F4A3",
+ "/book": "\u1F56E",
+ "/bookmark": "\u1F516",
+ "/bookmarkTabs": "\u1F4D1",
+ "/books": "\u1F4DA",
+ "/bopo:a": "\u311A",
+ "/bopo:ai": "\u311E",
+ "/bopo:an": "\u3122",
+ "/bopo:ang": "\u3124",
+ "/bopo:au": "\u3120",
+ "/bopo:b": "\u3105",
+ "/bopo:c": "\u3118",
+ "/bopo:ch": "\u3114",
+ "/bopo:d": "\u3109",
+ "/bopo:e": "\u311C",
+ "/bopo:eh": "\u311D",
+ "/bopo:ei": "\u311F",
+ "/bopo:en": "\u3123",
+ "/bopo:eng": "\u3125",
+ "/bopo:er": "\u3126",
+ "/bopo:f": "\u3108",
+ "/bopo:g": "\u310D",
+ "/bopo:gn": "\u312C",
+ "/bopo:h": "\u310F",
+ "/bopo:i": "\u3127",
+ "/bopo:ih": "\u312D",
+ "/bopo:iu": "\u3129",
+ "/bopo:j": "\u3110",
+ "/bopo:k": "\u310E",
+ "/bopo:l": "\u310C",
+ "/bopo:m": "\u3107",
+ "/bopo:n": "\u310B",
+ "/bopo:ng": "\u312B",
+ "/bopo:o": "\u311B",
+ "/bopo:ou": "\u3121",
+ "/bopo:owithdotabove": "\u312E",
+ "/bopo:p": "\u3106",
+ "/bopo:q": "\u3111",
+ "/bopo:r": "\u3116",
+ "/bopo:s": "\u3119",
+ "/bopo:sh": "\u3115",
+ "/bopo:t": "\u310A",
+ "/bopo:u": "\u3128",
+ "/bopo:v": "\u312A",
+ "/bopo:x": "\u3112",
+ "/bopo:z": "\u3117",
+ "/bopo:zh": "\u3113",
+ "/borutosquare": "\u333E",
+ "/bottlePoppingCork": "\u1F37E",
+ "/bouquet": "\u1F490",
+ "/bouquetOfFlowers": "\u1F395",
+ "/bowAndArrow": "\u1F3F9",
+ "/bowlOfHygieia": "\u1F54F",
+ "/bowling": "\u1F3B3",
+ "/boxlineverticalleft": "\u23B8",
+ "/boxlineverticalright": "\u23B9",
+ "/boy": "\u1F466",
+ "/boys": "\u1F6C9",
+ "/bparen": "\u249D",
+ "/bparenthesized": "\u249D",
+ "/bqfullwidth": "\u33C3",
+ "/bqsquare": "\u33C3",
+ "/braceex": "\uF8F4",
+ "/braceleft": "\u007B",
+ "/braceleftbt": "\uF8F3",
+ "/braceleftmid": "\uF8F2",
+ "/braceleftmonospace": "\uFF5B",
+ "/braceleftsmall": "\uFE5B",
+ "/bracelefttp": "\uF8F1",
+ "/braceleftvertical": "\uFE37",
+ "/braceright": "\u007D",
+ "/bracerightbt": "\uF8FE",
+ "/bracerightmid": "\uF8FD",
+ "/bracerightmonospace": "\uFF5D",
+ "/bracerightsmall": "\uFE5C",
+ "/bracerighttp": "\uF8FC",
+ "/bracerightvertical": "\uFE38",
+ "/bracketangledblleft": "\u27EA",
+ "/bracketangledblright": "\u27EB",
+ "/bracketangleleft": "\u27E8",
+ "/bracketangleright": "\u27E9",
+ "/bracketbottomcurly": "\u23DF",
+ "/bracketbottomsquare": "\u23B5",
+ "/bracketcornerupleftsquare": "\u23A1",
+ "/bracketcorneruprightsquare": "\u23A4",
+ "/bracketdottedsubstitutionleft": "\u2E04",
+ "/bracketdottedsubstitutionright": "\u2E05",
+ "/bracketextensioncurly": "\u23AA",
+ "/bracketextensionleftsquare": "\u23A2",
+ "/bracketextensionrightsquare": "\u23A5",
+ "/brackethalfbottomleft": "\u2E24",
+ "/brackethalfbottomright": "\u2E25",
+ "/brackethalftopleft": "\u2E22",
+ "/brackethalftopright": "\u2E23",
+ "/brackethookupleftcurly": "\u23A7",
+ "/brackethookuprightcurly": "\u23AB",
+ "/bracketleft": "\u005B",
+ "/bracketleftbt": "\uF8F0",
+ "/bracketleftex": "\uF8EF",
+ "/bracketleftmonospace": "\uFF3B",
+ "/bracketleftsquarequill": "\u2045",
+ "/bracketlefttp": "\uF8EE",
+ "/bracketlowercornerleftsquare": "\u23A3",
+ "/bracketlowercornerrightsquare": "\u23A6",
+ "/bracketlowerhookleftcurly": "\u23A9",
+ "/bracketlowerhookrightcurly": "\u23AD",
+ "/bracketmiddlepieceleftcurly": "\u23A8",
+ "/bracketmiddlepiecerightcurly": "\u23AC",
+ "/bracketoverbrackettopbottomsquare": "\u23B6",
+ "/bracketparaphraselowleft": "\u2E1C",
+ "/bracketparaphraselowright": "\u2E1D",
+ "/bracketraisedleft": "\u2E0C",
+ "/bracketraisedright": "\u2E0D",
+ "/bracketright": "\u005D",
+ "/bracketrightbt": "\uF8FB",
+ "/bracketrightex": "\uF8FA",
+ "/bracketrightmonospace": "\uFF3D",
+ "/bracketrightsquarequill": "\u2046",
+ "/bracketrighttp": "\uF8F9",
+ "/bracketsectionupleftlowerrightcurly": "\u23B0",
+ "/bracketsectionuprightlowerleftcurly": "\u23B1",
+ "/bracketshellbottom": "\u23E1",
+ "/bracketshelltop": "\u23E0",
+ "/bracketshellwhiteleft": "\u27EC",
+ "/bracketshellwhiteright": "\u27ED",
+ "/bracketsubstitutionleft": "\u2E02",
+ "/bracketsubstitutionright": "\u2E03",
+ "/brackettopcurly": "\u23DE",
+ "/brackettopsquare": "\u23B4",
+ "/brackettranspositionleft": "\u2E09",
+ "/brackettranspositionright": "\u2E0A",
+ "/bracketwhitesquareleft": "\u27E6",
+ "/bracketwhitesquareright": "\u27E7",
+ "/branchbankidentification": "\u2446",
+ "/bread": "\u1F35E",
+ "/breve": "\u02D8",
+ "/brevebelowcmb": "\u032E",
+ "/brevecmb": "\u0306",
+ "/breveinvertedbelowcmb": "\u032F",
+ "/breveinvertedcmb": "\u0311",
+ "/breveinverteddoublecmb": "\u0361",
+ "/brevemetrical": "\u23D1",
+ "/brideVeil": "\u1F470",
+ "/bridgeAtNight": "\u1F309",
+ "/bridgebelowcmb": "\u032A",
+ "/bridgeinvertedbelowcmb": "\u033A",
+ "/briefcase": "\u1F4BC",
+ "/brll:blank": "\u2800",
+ "/brokenHeart": "\u1F494",
+ "/brokenbar": "\u00A6",
+ "/brokencirclenorthwestarrow": "\u238B",
+ "/bstroke": "\u0180",
+ "/bsuperior": "\uF6EA",
+ "/btopbar": "\u0183",
+ "/bug": "\u1F41B",
+ "/buhiragana": "\u3076",
+ "/buildingConstruction": "\u1F3D7",
+ "/bukatakana": "\u30D6",
+ "/bullet": "\u2022",
+ "/bulletinverse": "\u25D8",
+ "/bulletoperator": "\u2219",
+ "/bullhorn": "\u1F56B",
+ "/bullhornSoundWaves": "\u1F56C",
+ "/bullseye": "\u25CE",
+ "/burrito": "\u1F32F",
+ "/bus": "\u1F68C",
+ "/busStop": "\u1F68F",
+ "/bussyerusquare": "\u3334",
+ "/bustInSilhouette": "\u1F464",
+ "/bustsInSilhouette": "\u1F465",
+ "/c": "\u0063",
+ "/caarmenian": "\u056E",
+ "/cabengali": "\u099A",
+ "/cactus": "\u1F335",
+ "/cacute": "\u0107",
+ "/cadauna": "\u2106",
+ "/cadeva": "\u091A",
+ "/caduceus": "\u2624",
+ "/cagujarati": "\u0A9A",
+ "/cagurmukhi": "\u0A1A",
+ "/cakraconsonant": "\uA9BF",
+ "/calendar": "\u1F4C5",
+ "/calfullwidth": "\u3388",
+ "/callideographicparen": "\u323A",
+ "/calsquare": "\u3388",
+ "/camera": "\u1F4F7",
+ "/cameraFlash": "\u1F4F8",
+ "/camping": "\u1F3D5",
+ "/camurda": "\uA996",
+ "/cancellationX": "\u1F5D9",
+ "/cancer": "\u264B",
+ "/candle": "\u1F56F",
+ "/candrabindubengali": "\u0981",
+ "/candrabinducmb": "\u0310",
+ "/candrabindudeva": "\u0901",
+ "/candrabindugujarati": "\u0A81",
+ "/candy": "\u1F36C",
+ "/canoe": "\u1F6F6",
+ "/capitulum": "\u2E3F",
+ "/capricorn": "\u2651",
+ "/capslock": "\u21EA",
+ "/cardFileBox": "\u1F5C3",
+ "/cardIndex": "\u1F4C7",
+ "/cardIndexDividers": "\u1F5C2",
+ "/careof": "\u2105",
+ "/caret": "\u2038",
+ "/caretinsertionpoint": "\u2041",
+ "/carettildedownfunc": "\u2371",
+ "/carettildeupfunc": "\u2372",
+ "/caron": "\u02C7",
+ "/caronbelowcmb": "\u032C",
+ "/caroncmb": "\u030C",
+ "/carouselHorse": "\u1F3A0",
+ "/carpStreamer": "\u1F38F",
+ "/carriagereturn": "\u21B5",
+ "/carsliding": "\u26D0",
+ "/castle": "\u26EB",
+ "/cat": "\u1F408",
+ "/catFace": "\u1F431",
+ "/catFaceWithTearsOfJoy": "\u1F639",
+ "/catFaceWithWrySmile": "\u1F63C",
+ "/caution": "\u2621",
+ "/cbar": "\uA793",
+ "/cbopomofo": "\u3118",
+ "/ccaron": "\u010D",
+ "/ccedilla": "\u00E7",
+ "/ccedillaacute": "\u1E09",
+ "/ccfullwidth": "\u33C4",
+ "/ccircle": "\u24D2",
+ "/ccircumflex": "\u0109",
+ "/ccurl": "\u0255",
+ "/cdfullwidth": "\u33C5",
+ "/cdot": "\u010B",
+ "/cdotaccent": "\u010B",
+ "/cdotreversed": "\uA73F",
+ "/cdsquare": "\u33C5",
+ "/cecak": "\uA981",
+ "/cecaktelu": "\uA9B3",
+ "/cedi": "\u20B5",
+ "/cedilla": "\u00B8",
+ "/cedillacmb": "\u0327",
+ "/ceilingleft": "\u2308",
+ "/ceilingright": "\u2309",
+ "/celticCross": "\u1F548",
+ "/cent": "\u00A2",
+ "/centigrade": "\u2103",
+ "/centinferior": "\uF6DF",
+ "/centmonospace": "\uFFE0",
+ "/centoldstyle": "\uF7A2",
+ "/centreddotwhitediamond": "\u27D0",
+ "/centreideographiccircled": "\u32A5",
+ "/centreline": "\u2104",
+ "/centrelineverticalsquarewhite": "\u2385",
+ "/centsuperior": "\uF6E0",
+ "/ceres": "\u26B3",
+ "/chaarmenian": "\u0579",
+ "/chabengali": "\u099B",
+ "/chadeva": "\u091B",
+ "/chagujarati": "\u0A9B",
+ "/chagurmukhi": "\u0A1B",
+ "/chains": "\u26D3",
+ "/chair": "\u2441",
+ "/chamkocircle": "\u327C",
+ "/charactertie": "\u2040",
+ "/chartDownwardsTrend": "\u1F4C9",
+ "/chartUpwardsTrend": "\u1F4C8",
+ "/chartUpwardsTrendAndYenSign": "\u1F4B9",
+ "/chbopomofo": "\u3114",
+ "/cheabkhasiancyrillic": "\u04BD",
+ "/cheabkhcyr": "\u04BD",
+ "/cheabkhtailcyr": "\u04BF",
+ "/checkbox": "\u2610",
+ "/checkboxchecked": "\u2611",
+ "/checkboxx": "\u2612",
+ "/checkmark": "\u2713",
+ "/checyr": "\u0447",
+ "/checyrillic": "\u0447",
+ "/chedescenderabkhasiancyrillic": "\u04BF",
+ "/chedescendercyrillic": "\u04B7",
+ "/chedieresiscyr": "\u04F5",
+ "/chedieresiscyrillic": "\u04F5",
+ "/cheeringMegaphone": "\u1F4E3",
+ "/cheharmenian": "\u0573",
+ "/chekhakascyr": "\u04CC",
+ "/chekhakassiancyrillic": "\u04CC",
+ "/chequeredFlag": "\u1F3C1",
+ "/cherries": "\u1F352",
+ "/cherryBlossom": "\u1F338",
+ "/chestnut": "\u1F330",
+ "/chetailcyr": "\u04B7",
+ "/chevertcyr": "\u04B9",
+ "/cheverticalstrokecyrillic": "\u04B9",
+ "/chi": "\u03C7",
+ "/chicken": "\u1F414",
+ "/chieuchacirclekorean": "\u3277",
+ "/chieuchaparenkorean": "\u3217",
+ "/chieuchcirclekorean": "\u3269",
+ "/chieuchkorean": "\u314A",
+ "/chieuchparenkorean": "\u3209",
+ "/childrenCrossing": "\u1F6B8",
+ "/chipmunk": "\u1F43F",
+ "/chirho": "\u2627",
+ "/chiron": "\u26B7",
+ "/chochangthai": "\u0E0A",
+ "/chochanthai": "\u0E08",
+ "/chochingthai": "\u0E09",
+ "/chochoethai": "\u0E0C",
+ "/chocolateBar": "\u1F36B",
+ "/chook": "\u0188",
+ "/christmasTree": "\u1F384",
+ "/church": "\u26EA",
+ "/cieucacirclekorean": "\u3276",
+ "/cieucaparenkorean": "\u3216",
+ "/cieuccirclekorean": "\u3268",
+ "/cieuckorean": "\u3148",
+ "/cieucparenkorean": "\u3208",
+ "/cieucuparenkorean": "\u321C",
+ "/cinema": "\u1F3A6",
+ "/circle": "\u25CB",
+ "/circleallbutupperquadrantleftblack": "\u25D5",
+ "/circlebackslashfunc": "\u2349",
+ "/circleblack": "\u25CF",
+ "/circledCrossPommee": "\u1F540",
+ "/circledInformationSource": "\u1F6C8",
+ "/circledasteriskoperator": "\u229B",
+ "/circledbarnotchhorizontal": "\u2389",
+ "/circledcrossinglanes": "\u26D2",
+ "/circleddash": "\u229D",
+ "/circleddivisionslash": "\u2298",
+ "/circleddotoperator": "\u2299",
+ "/circledequals": "\u229C",
+ "/circlediaeresisfunc": "\u2365",
+ "/circledminus": "\u2296",
+ "/circledot": "\u2299",
+ "/circledotrightwhite": "\u2686",
+ "/circledotted": "\u25CC",
+ "/circledringoperator": "\u229A",
+ "/circledtriangledown": "\u238A",
+ "/circlehalfleftblack": "\u25D0",
+ "/circlehalfrightblack": "\u25D1",
+ "/circleinversewhite": "\u25D9",
+ "/circlejotfunc": "\u233E",
+ "/circlelowerhalfblack": "\u25D2",
+ "/circlelowerquadrantleftwhite": "\u25F5",
+ "/circlelowerquadrantrightwhite": "\u25F6",
+ "/circlemultiply": "\u2297",
+ "/circleot": "\u2299",
+ "/circleplus": "\u2295",
+ "/circlepostalmark": "\u3036",
+ "/circlestarfunc": "\u235F",
+ "/circlestilefunc": "\u233D",
+ "/circlestroketwodotsaboveheavy": "\u26E3",
+ "/circletwodotsblackwhite": "\u2689",
+ "/circletwodotswhite": "\u2687",
+ "/circleunderlinefunc": "\u235C",
+ "/circleupperhalfblack": "\u25D3",
+ "/circleupperquadrantleftwhite": "\u25F4",
+ "/circleupperquadrantrightblack": "\u25D4",
+ "/circleupperquadrantrightwhite": "\u25F7",
+ "/circleverticalfill": "\u25CD",
+ "/circlewhite": "\u25CB",
+ "/circlewhitedotrightblack": "\u2688",
+ "/circlewithlefthalfblack": "\u25D0",
+ "/circlewithrighthalfblack": "\u25D1",
+ "/circumflex": "\u02C6",
+ "/circumflexbelowcmb": "\u032D",
+ "/circumflexcmb": "\u0302",
+ "/circumflexlow": "\uA788",
+ "/circusTent": "\u1F3AA",
+ "/cityscape": "\u1F3D9",
+ "/cityscapeAtDusk": "\u1F306",
+ "/cjk:ideographiccomma": "\u3001",
+ "/cjk:tortoiseshellbracketleft": "\u3014",
+ "/cjk:tortoiseshellbracketright": "\u3015",
+ "/clamshellMobilePhone": "\u1F581",
+ "/clapperBoard": "\u1F3AC",
+ "/clappingHandsSign": "\u1F44F",
+ "/classicalBuilding": "\u1F3DB",
+ "/clear": "\u2327",
+ "/clearscreen": "\u239A",
+ "/clickalveolar": "\u01C2",
+ "/clickbilabial": "\u0298",
+ "/clickdental": "\u01C0",
+ "/clicklateral": "\u01C1",
+ "/clickretroflex": "\u01C3",
+ "/clinkingBeerMugs": "\u1F37B",
+ "/clipboard": "\u1F4CB",
+ "/clockFaceEight-thirty": "\u1F563",
+ "/clockFaceEightOclock": "\u1F557",
+ "/clockFaceEleven-thirty": "\u1F566",
+ "/clockFaceElevenOclock": "\u1F55A",
+ "/clockFaceFive-thirty": "\u1F560",
+ "/clockFaceFiveOclock": "\u1F554",
+ "/clockFaceFour-thirty": "\u1F55F",
+ "/clockFaceFourOclock": "\u1F553",
+ "/clockFaceNine-thirty": "\u1F564",
+ "/clockFaceNineOclock": "\u1F558",
+ "/clockFaceOne-thirty": "\u1F55C",
+ "/clockFaceOneOclock": "\u1F550",
+ "/clockFaceSeven-thirty": "\u1F562",
+ "/clockFaceSevenOclock": "\u1F556",
+ "/clockFaceSix-thirty": "\u1F561",
+ "/clockFaceSixOclock": "\u1F555",
+ "/clockFaceTen-thirty": "\u1F565",
+ "/clockFaceTenOclock": "\u1F559",
+ "/clockFaceThree-thirty": "\u1F55E",
+ "/clockFaceThreeOclock": "\u1F552",
+ "/clockFaceTwelve-thirty": "\u1F567",
+ "/clockFaceTwelveOclock": "\u1F55B",
+ "/clockFaceTwo-thirty": "\u1F55D",
+ "/clockFaceTwoOclock": "\u1F551",
+ "/clockwiseDownwardsAndUpwardsOpenCircleArrows": "\u1F503",
+ "/clockwiseRightAndLeftSemicircleArrows": "\u1F5D8",
+ "/clockwiseRightwardsAndLeftwardsOpenCircleArrows": "\u1F501",
+ "/clockwiseRightwardsAndLeftwardsOpenCircleArrowsCircledOneOverlay": "\u1F502",
+ "/closedBook": "\u1F4D5",
+ "/closedLockKey": "\u1F510",
+ "/closedMailboxLoweredFlag": "\u1F4EA",
+ "/closedMailboxRaisedFlag": "\u1F4EB",
+ "/closedUmbrella": "\u1F302",
+ "/closedentryleft": "\u26DC",
+ "/closeup": "\u2050",
+ "/cloud": "\u2601",
+ "/cloudLightning": "\u1F329",
+ "/cloudRain": "\u1F327",
+ "/cloudSnow": "\u1F328",
+ "/cloudTornado": "\u1F32A",
+ "/clsquare": "\u1F191",
+ "/club": "\u2663",
+ "/clubblack": "\u2663",
+ "/clubsuitblack": "\u2663",
+ "/clubsuitwhite": "\u2667",
+ "/clubwhite": "\u2667",
+ "/cm2fullwidth": "\u33A0",
+ "/cm3fullwidth": "\u33A4",
+ "/cmb:a": "\u0363",
+ "/cmb:aaboveflat": "\u1DD3",
+ "/cmb:aboveogonek": "\u1DCE",
+ "/cmb:acute": "\u0301",
+ "/cmb:acutebelow": "\u0317",
+ "/cmb:acutegraveacute": "\u1DC9",
+ "/cmb:acutemacron": "\u1DC7",
+ "/cmb:acutetone": "\u0341",
+ "/cmb:adieresis": "\u1DF2",
+ "/cmb:ae": "\u1DD4",
+ "/cmb:almostequalabove": "\u034C",
+ "/cmb:almostequaltobelow": "\u1DFD",
+ "/cmb:alpha": "\u1DE7",
+ "/cmb:ao": "\u1DD5",
+ "/cmb:arrowheadleftbelow": "\u0354",
+ "/cmb:arrowheadrightabove": "\u0350",
+ "/cmb:arrowheadrightarrowheadupbelow": "\u0356",
+ "/cmb:arrowheadrightbelow": "\u0355",
+ "/cmb:arrowleftrightbelow": "\u034D",
+ "/cmb:arrowrightdoublebelow": "\u0362",
+ "/cmb:arrowupbelow": "\u034E",
+ "/cmb:asteriskbelow": "\u0359",
+ "/cmb:av": "\u1DD6",
+ "/cmb:b": "\u1DE8",
+ "/cmb:belowbreve": "\u032E",
+ "/cmb:beta": "\u1DE9",
+ "/cmb:breve": "\u0306",
+ "/cmb:brevemacron": "\u1DCB",
+ "/cmb:bridgeabove": "\u0346",
+ "/cmb:bridgebelow": "\u032A",
+ "/cmb:c": "\u0368",
+ "/cmb:candrabindu": "\u0310",
+ "/cmb:caron": "\u030C",
+ "/cmb:caronbelow": "\u032C",
+ "/cmb:ccedilla": "\u1DD7",
+ "/cmb:cedilla": "\u0327",
+ "/cmb:circumflex": "\u0302",
+ "/cmb:circumflexbelow": "\u032D",
+ "/cmb:commaaccentbelow": "\u0326",
+ "/cmb:commaturnedabove": "\u0312",
+ "/cmb:d": "\u0369",
+ "/cmb:dblarchinvertedbelow": "\u032B",
+ "/cmb:dbloverline": "\u033F",
+ "/cmb:dblverticallineabove": "\u030E",
+ "/cmb:dblverticallinebelow": "\u0348",
+ "/cmb:deletionmark": "\u1DFB",
+ "/cmb:dialytikatonos": "\u0344",
+ "/cmb:dieresis": "\u0308",
+ "/cmb:dieresisbelow": "\u0324",
+ "/cmb:dotaboveleft": "\u1DF8",
+ "/cmb:dotaccent": "\u0307",
+ "/cmb:dotbelowcomb": "\u0323",
+ "/cmb:dotrightabove": "\u0358",
+ "/cmb:dottedacute": "\u1DC1",
+ "/cmb:dottedgrave": "\u1DC0",
+ "/cmb:doubleabovecircumflex": "\u1DCD",
+ "/cmb:doublebelowbreve": "\u035C",
+ "/cmb:doublebreve": "\u035D",
+ "/cmb:doubleinvertedbelowbreve": "\u1DFC",
+ "/cmb:doubleringbelow": "\u035A",
+ "/cmb:downtackbelow": "\u031E",
+ "/cmb:e": "\u0364",
+ "/cmb:equalbelow": "\u0347",
+ "/cmb:esh": "\u1DEF",
+ "/cmb:eth": "\u1DD9",
+ "/cmb:f": "\u1DEB",
+ "/cmb:fermata": "\u0352",
+ "/cmb:g": "\u1DDA",
+ "/cmb:graphemejoiner": "\u034F",
+ "/cmb:grave": "\u0300",
+ "/cmb:graveacutegrave": "\u1DC8",
+ "/cmb:gravebelow": "\u0316",
+ "/cmb:gravedouble": "\u030F",
+ "/cmb:gravemacron": "\u1DC5",
+ "/cmb:gravetone": "\u0340",
+ "/cmb:gsmall": "\u1DDB",
+ "/cmb:h": "\u036A",
+ "/cmb:halfleftringabove": "\u0351",
+ "/cmb:halfleftringbelow": "\u031C",
+ "/cmb:halfrightringabove": "\u0357",
+ "/cmb:halfrightringbelow": "\u0339",
+ "/cmb:homotheticabove": "\u034B",
+ "/cmb:hookabove": "\u0309",
+ "/cmb:horn": "\u031B",
+ "/cmb:hungarumlaut": "\u030B",
+ "/cmb:i": "\u0365",
+ "/cmb:insulard": "\u1DD8",
+ "/cmb:invertedbelowbreve": "\u032F",
+ "/cmb:invertedbreve": "\u0311",
+ "/cmb:invertedbridgebelow": "\u033A",
+ "/cmb:inverteddoublebreve": "\u0361",
+ "/cmb:iotasub": "\u0345",
+ "/cmb:isbelow": "\u1DD0",
+ "/cmb:k": "\u1DDC",
+ "/cmb:kavykaaboveleft": "\u1DF7",
+ "/cmb:kavykaaboveright": "\u1DF6",
+ "/cmb:koronis": "\u0343",
+ "/cmb:l": "\u1DDD",
+ "/cmb:leftangleabove": "\u031A",
+ "/cmb:leftanglebelow": "\u0349",
+ "/cmb:leftarrowheadabove": "\u1DFE",
+ "/cmb:lefttackbelow": "\u0318",
+ "/cmb:lineverticalabove": "\u030D",
+ "/cmb:lineverticalbelow": "\u0329",
+ "/cmb:longs": "\u1DE5",
+ "/cmb:lowline": "\u0332",
+ "/cmb:lowlinedouble": "\u0333",
+ "/cmb:lsmall": "\u1DDE",
+ "/cmb:lwithdoublemiddletilde": "\u1DEC",
+ "/cmb:m": "\u036B",
+ "/cmb:macron": "\u0304",
+ "/cmb:macronacute": "\u1DC4",
+ "/cmb:macronbelow": "\u0331",
+ "/cmb:macronbreve": "\u1DCC",
+ "/cmb:macrondouble": "\u035E",
+ "/cmb:macrondoublebelow": "\u035F",
+ "/cmb:macrongrave": "\u1DC6",
+ "/cmb:minusbelow": "\u0320",
+ "/cmb:msmall": "\u1DDF",
+ "/cmb:n": "\u1DE0",
+ "/cmb:nottildeabove": "\u034A",
+ "/cmb:nsmall": "\u1DE1",
+ "/cmb:o": "\u0366",
+ "/cmb:odieresis": "\u1DF3",
+ "/cmb:ogonek": "\u0328",
+ "/cmb:overlaystrokelong": "\u0336",
+ "/cmb:overlaystrokeshort": "\u0335",
+ "/cmb:overline": "\u0305",
+ "/cmb:owithlightcentralizationstroke": "\u1DED",
+ "/cmb:p": "\u1DEE",
+ "/cmb:palatalizedhookbelow": "\u0321",
+ "/cmb:perispomeni": "\u0342",
+ "/cmb:plusbelow": "\u031F",
+ "/cmb:r": "\u036C",
+ "/cmb:rbelow": "\u1DCA",
+ "/cmb:retroflexhookbelow": "\u0322",
+ "/cmb:reversedcommaabove": "\u0314",
+ "/cmb:rightarrowheadanddownarrowheadbelow": "\u1DFF",
+ "/cmb:righttackbelow": "\u0319",
+ "/cmb:ringabove": "\u030A",
+ "/cmb:ringbelow": "\u0325",
+ "/cmb:rrotunda": "\u1DE3",
+ "/cmb:rsmall": "\u1DE2",
+ "/cmb:s": "\u1DE4",
+ "/cmb:schwa": "\u1DEA",
+ "/cmb:seagullbelow": "\u033C",
+ "/cmb:snakebelow": "\u1DC2",
+ "/cmb:soliduslongoverlay": "\u0338",
+ "/cmb:solidusshortoverlay": "\u0337",
+ "/cmb:squarebelow": "\u033B",
+ "/cmb:suspensionmark": "\u1DC3",
+ "/cmb:t": "\u036D",
+ "/cmb:tilde": "\u0303",
+ "/cmb:tildebelow": "\u0330",
+ "/cmb:tildedouble": "\u0360",
+ "/cmb:tildeoverlay": "\u0334",
+ "/cmb:tildevertical": "\u033E",
+ "/cmb:turnedabove": "\u0313",
+ "/cmb:turnedcommaabove": "\u0315",
+ "/cmb:u": "\u0367",
+ "/cmb:udieresis": "\u1DF4",
+ "/cmb:uptackabove": "\u1DF5",
+ "/cmb:uptackbelow": "\u031D",
+ "/cmb:urabove": "\u1DD1",
+ "/cmb:usabove": "\u1DD2",
+ "/cmb:uwithlightcentralizationstroke": "\u1DF0",
+ "/cmb:v": "\u036E",
+ "/cmb:w": "\u1DF1",
+ "/cmb:wideinvertedbridgebelow": "\u1DF9",
+ "/cmb:x": "\u036F",
+ "/cmb:xabove": "\u033D",
+ "/cmb:xbelow": "\u0353",
+ "/cmb:z": "\u1DE6",
+ "/cmb:zigzagabove": "\u035B",
+ "/cmb:zigzagbelow": "\u1DCF",
+ "/cmcubedsquare": "\u33A4",
+ "/cmfullwidth": "\u339D",
+ "/cmonospace": "\uFF43",
+ "/cmsquaredsquare": "\u33A0",
+ "/cntr:acknowledge": "\u2406",
+ "/cntr:backspace": "\u2408",
+ "/cntr:bell": "\u2407",
+ "/cntr:blank": "\u2422",
+ "/cntr:cancel": "\u2418",
+ "/cntr:carriagereturn": "\u240D",
+ "/cntr:datalinkescape": "\u2410",
+ "/cntr:delete": "\u2421",
+ "/cntr:deleteformtwo": "\u2425",
+ "/cntr:devicecontrolfour": "\u2414",
+ "/cntr:devicecontrolone": "\u2411",
+ "/cntr:devicecontrolthree": "\u2413",
+ "/cntr:devicecontroltwo": "\u2412",
+ "/cntr:endofmedium": "\u2419",
+ "/cntr:endoftext": "\u2403",
+ "/cntr:endoftransmission": "\u2404",
+ "/cntr:endoftransmissionblock": "\u2417",
+ "/cntr:enquiry": "\u2405",
+ "/cntr:escape": "\u241B",
+ "/cntr:fileseparator": "\u241C",
+ "/cntr:formfeed": "\u240C",
+ "/cntr:groupseparator": "\u241D",
+ "/cntr:horizontaltab": "\u2409",
+ "/cntr:linefeed": "\u240A",
+ "/cntr:negativeacknowledge": "\u2415",
+ "/cntr:newline": "\u2424",
+ "/cntr:null": "\u2400",
+ "/cntr:openbox": "\u2423",
+ "/cntr:recordseparator": "\u241E",
+ "/cntr:shiftin": "\u240F",
+ "/cntr:shiftout": "\u240E",
+ "/cntr:space": "\u2420",
+ "/cntr:startofheading": "\u2401",
+ "/cntr:startoftext": "\u2402",
+ "/cntr:substitute": "\u241A",
+ "/cntr:substituteformtwo": "\u2426",
+ "/cntr:synchronousidle": "\u2416",
+ "/cntr:unitseparator": "\u241F",
+ "/cntr:verticaltab": "\u240B",
+ "/coarmenian": "\u0581",
+ "/cocktailGlass": "\u1F378",
+ "/coffin": "\u26B0",
+ "/cofullwidth": "\u33C7",
+ "/collision": "\u1F4A5",
+ "/colon": "\u003A",
+ "/colonequals": "\u2254",
+ "/colonmod": "\uA789",
+ "/colonmonetary": "\u20A1",
+ "/colonmonospace": "\uFF1A",
+ "/colonraisedmod": "\u02F8",
+ "/colonsign": "\u20A1",
+ "/colonsmall": "\uFE55",
+ "/colontriangularhalfmod": "\u02D1",
+ "/colontriangularmod": "\u02D0",
+ "/comet": "\u2604",
+ "/comma": "\u002C",
+ "/commaabovecmb": "\u0313",
+ "/commaaboverightcmb": "\u0315",
+ "/commaaccent": "\uF6C3",
+ "/commaarabic": "\u060C",
+ "/commaarmenian": "\u055D",
+ "/commabarfunc": "\u236A",
+ "/commainferior": "\uF6E1",
+ "/commamonospace": "\uFF0C",
+ "/commaraised": "\u2E34",
+ "/commareversed": "\u2E41",
+ "/commareversedabovecmb": "\u0314",
+ "/commareversedmod": "\u02BD",
+ "/commasmall": "\uFE50",
+ "/commasuperior": "\uF6E2",
+ "/commaturnedabovecmb": "\u0312",
+ "/commaturnedmod": "\u02BB",
+ "/commercialat": "\uFE6B",
+ "/commercialminussign": "\u2052",
+ "/compass": "\u263C",
+ "/complement": "\u2201",
+ "/composition": "\u2384",
+ "/compression": "\u1F5DC",
+ "/con": "\uA76F",
+ "/confettiBall": "\u1F38A",
+ "/confoundedFace": "\u1F616",
+ "/confusedFace": "\u1F615",
+ "/congratulationideographiccircled": "\u3297",
+ "/congratulationideographicparen": "\u3237",
+ "/congruent": "\u2245",
+ "/conicaltaper": "\u2332",
+ "/conjunction": "\u260C",
+ "/consquareupblack": "\u26FE",
+ "/constructionSign": "\u1F6A7",
+ "/constructionWorker": "\u1F477",
+ "/containsasmembersmall": "\u220D",
+ "/containsasnormalsubgroorequalup": "\u22B5",
+ "/containsasnormalsubgroup": "\u22B3",
+ "/containslonghorizontalstroke": "\u22FA",
+ "/containsoverbar": "\u22FD",
+ "/containsoverbarsmall": "\u22FE",
+ "/containssmallverticalbarhorizontalstroke": "\u22FC",
+ "/containsverticalbarhorizontalstroke": "\u22FB",
+ "/continuousunderline": "\u2381",
+ "/contourintegral": "\u222E",
+ "/control": "\u2303",
+ "/controlACK": "\u0006",
+ "/controlBEL": "\u0007",
+ "/controlBS": "\u0008",
+ "/controlCAN": "\u0018",
+ "/controlCR": "\u000D",
+ "/controlDC1": "\u0011",
+ "/controlDC2": "\u0012",
+ "/controlDC3": "\u0013",
+ "/controlDC4": "\u0014",
+ "/controlDEL": "\u007F",
+ "/controlDLE": "\u0010",
+ "/controlEM": "\u0019",
+ "/controlENQ": "\u0005",
+ "/controlEOT": "\u0004",
+ "/controlESC": "\u001B",
+ "/controlETB": "\u0017",
+ "/controlETX": "\u0003",
+ "/controlFF": "\u000C",
+ "/controlFS": "\u001C",
+ "/controlGS": "\u001D",
+ "/controlHT": "\u0009",
+ "/controlKnobs": "\u1F39B",
+ "/controlLF": "\u000A",
+ "/controlNAK": "\u0015",
+ "/controlRS": "\u001E",
+ "/controlSI": "\u000F",
+ "/controlSO": "\u000E",
+ "/controlSOT": "\u0002",
+ "/controlSTX": "\u0001",
+ "/controlSUB": "\u001A",
+ "/controlSYN": "\u0016",
+ "/controlUS": "\u001F",
+ "/controlVT": "\u000B",
+ "/convavediamondwhite": "\u27E1",
+ "/convenienceStore": "\u1F3EA",
+ "/cookedRice": "\u1F35A",
+ "/cookie": "\u1F36A",
+ "/cooking": "\u1F373",
+ "/coolsquare": "\u1F192",
+ "/coproductarray": "\u2210",
+ "/copyideographiccircled": "\u32A2",
+ "/copyright": "\u00A9",
+ "/copyrightsans": "\uF8E9",
+ "/copyrightserif": "\uF6D9",
+ "/cornerbottomleft": "\u231E",
+ "/cornerbottomright": "\u231F",
+ "/cornerbracketleft": "\u300C",
+ "/cornerbracketlefthalfwidth": "\uFF62",
+ "/cornerbracketleftvertical": "\uFE41",
+ "/cornerbracketright": "\u300D",
+ "/cornerbracketrighthalfwidth": "\uFF63",
+ "/cornerbracketrightvertical": "\uFE42",
+ "/cornerdotupleft": "\u27D4",
+ "/cornertopleft": "\u231C",
+ "/cornertopright": "\u231D",
+ "/coroniseditorial": "\u2E0E",
+ "/corporationsquare": "\u337F",
+ "/correctideographiccircled": "\u32A3",
+ "/corresponds": "\u2258",
+ "/cosquare": "\u33C7",
+ "/couchAndLamp": "\u1F6CB",
+ "/counterbore": "\u2334",
+ "/countersink": "\u2335",
+ "/coupleHeart": "\u1F491",
+ "/coverkgfullwidth": "\u33C6",
+ "/coverkgsquare": "\u33C6",
+ "/cow": "\u1F404",
+ "/cowFace": "\u1F42E",
+ "/cpalatalhook": "\uA794",
+ "/cparen": "\u249E",
+ "/cparenthesized": "\u249E",
+ "/creditCard": "\u1F4B3",
+ "/crescentMoon": "\u1F319",
+ "/creversed": "\u2184",
+ "/cricketBatAndBall": "\u1F3CF",
+ "/crocodile": "\u1F40A",
+ "/cropbottomleft": "\u230D",
+ "/cropbottomright": "\u230C",
+ "/croptopleft": "\u230F",
+ "/croptopright": "\u230E",
+ "/crossPommee": "\u1F542",
+ "/crossPommeeHalf-circleBelow": "\u1F541",
+ "/crossedFlags": "\u1F38C",
+ "/crossedswords": "\u2694",
+ "/crossinglanes": "\u26CC",
+ "/crossmod": "\u02DF",
+ "/crossofjerusalem": "\u2629",
+ "/crossoflorraine": "\u2628",
+ "/crossonshieldblack": "\u26E8",
+ "/crown": "\u1F451",
+ "/crrn:rupee": "\u20A8",
+ "/cruzeiro": "\u20A2",
+ "/cryingCatFace": "\u1F63F",
+ "/cryingFace": "\u1F622",
+ "/crystalBall": "\u1F52E",
+ "/cstretched": "\u0297",
+ "/cstroke": "\u023C",
+ "/cuatrillo": "\uA72D",
+ "/cuatrillocomma": "\uA72F",
+ "/curlyand": "\u22CF",
+ "/curlylogicaland": "\u22CF",
+ "/curlylogicalor": "\u22CE",
+ "/curlyor": "\u22CE",
+ "/currency": "\u00A4",
+ "/currencyExchange": "\u1F4B1",
+ "/curryAndRice": "\u1F35B",
+ "/custard": "\u1F36E",
+ "/customeraccountnumber": "\u2449",
+ "/customs": "\u1F6C3",
+ "/cyclone": "\u1F300",
+ "/cylindricity": "\u232D",
+ "/cyrBreve": "\uF6D1",
+ "/cyrFlex": "\uF6D2",
+ "/cyrbreve": "\uF6D4",
+ "/cyrflex": "\uF6D5",
+ "/d": "\u0064",
+ "/daarmenian": "\u0564",
+ "/daasusquare": "\u3324",
+ "/dabengali": "\u09A6",
+ "/dad": "\u0636",
+ "/dad.fina": "\uFEBE",
+ "/dad.init": "\uFEBF",
+ "/dad.init_alefmaksura.fina": "\uFD07",
+ "/dad.init_hah.fina": "\uFC23",
+ "/dad.init_hah.medi": "\uFCB5",
+ "/dad.init_jeem.fina": "\uFC22",
+ "/dad.init_jeem.medi": "\uFCB4",
+ "/dad.init_khah.fina": "\uFC24",
+ "/dad.init_khah.medi": "\uFCB6",
+ "/dad.init_khah.medi_meem.medi": "\uFD70",
+ "/dad.init_meem.fina": "\uFC25",
+ "/dad.init_meem.medi": "\uFCB7",
+ "/dad.init_reh.fina": "\uFD10",
+ "/dad.init_yeh.fina": "\uFD08",
+ "/dad.isol": "\uFEBD",
+ "/dad.medi": "\uFEC0",
+ "/dad.medi_alefmaksura.fina": "\uFD23",
+ "/dad.medi_hah.medi_alefmaksura.fina": "\uFD6E",
+ "/dad.medi_hah.medi_yeh.fina": "\uFDAB",
+ "/dad.medi_khah.medi_meem.fina": "\uFD6F",
+ "/dad.medi_reh.fina": "\uFD2C",
+ "/dad.medi_yeh.fina": "\uFD24",
+ "/dadarabic": "\u0636",
+ "/daddotbelow": "\u06FB",
+ "/dadeva": "\u0926",
+ "/dadfinalarabic": "\uFEBE",
+ "/dadinitialarabic": "\uFEBF",
+ "/dadmedialarabic": "\uFEC0",
+ "/dafullwidth": "\u3372",
+ "/dagesh": "\u05BC",
+ "/dagesh:hb": "\u05BC",
+ "/dageshhebrew": "\u05BC",
+ "/dagger": "\u2020",
+ "/daggerKnife": "\u1F5E1",
+ "/daggerdbl": "\u2021",
+ "/daggerwithguardleft": "\u2E36",
+ "/daggerwithguardright": "\u2E37",
+ "/dagujarati": "\u0AA6",
+ "/dagurmukhi": "\u0A26",
+ "/dahal": "\u068C",
+ "/dahal.fina": "\uFB85",
+ "/dahal.isol": "\uFB84",
+ "/dahiragana": "\u3060",
+ "/dakatakana": "\u30C0",
+ "/dal": "\u062F",
+ "/dal.fina": "\uFEAA",
+ "/dal.isol": "\uFEA9",
+ "/dalInvertedSmallVBelow": "\u075A",
+ "/dalTwoDotsVerticallyBelowSmallTah": "\u0759",
+ "/dalarabic": "\u062F",
+ "/daldotbelow": "\u068A",
+ "/daldotbelowtahsmall": "\u068B",
+ "/daldownthreedotsabove": "\u068F",
+ "/dalet": "\u05D3",
+ "/dalet:hb": "\u05D3",
+ "/daletdagesh": "\uFB33",
+ "/daletdageshhebrew": "\uFB33",
+ "/dalethatafpatah": "\u05D3",
+ "/dalethatafpatahhebrew": "\u05D3",
+ "/dalethatafsegol": "\u05D3",
+ "/dalethatafsegolhebrew": "\u05D3",
+ "/dalethebrew": "\u05D3",
+ "/dalethiriq": "\u05D3",
+ "/dalethiriqhebrew": "\u05D3",
+ "/daletholam": "\u05D3",
+ "/daletholamhebrew": "\u05D3",
+ "/daletpatah": "\u05D3",
+ "/daletpatahhebrew": "\u05D3",
+ "/daletqamats": "\u05D3",
+ "/daletqamatshebrew": "\u05D3",
+ "/daletqubuts": "\u05D3",
+ "/daletqubutshebrew": "\u05D3",
+ "/daletsegol": "\u05D3",
+ "/daletsegolhebrew": "\u05D3",
+ "/daletsheva": "\u05D3",
+ "/daletshevahebrew": "\u05D3",
+ "/dalettsere": "\u05D3",
+ "/dalettserehebrew": "\u05D3",
+ "/daletwide:hb": "\uFB22",
+ "/daletwithdagesh:hb": "\uFB33",
+ "/dalfinalarabic": "\uFEAA",
+ "/dalfourdotsabove": "\u0690",
+ "/dalinvertedV": "\u06EE",
+ "/dalring": "\u0689",
+ "/damahaprana": "\uA9A3",
+ "/damma": "\u064F",
+ "/dammaIsol": "\uFE78",
+ "/dammaMedi": "\uFE79",
+ "/dammaarabic": "\u064F",
+ "/dammalowarabic": "\u064F",
+ "/dammareversed": "\u065D",
+ "/dammasmall": "\u0619",
+ "/dammatan": "\u064C",
+ "/dammatanIsol": "\uFE72",
+ "/dammatanaltonearabic": "\u064C",
+ "/dammatanarabic": "\u064C",
+ "/dancer": "\u1F483",
+ "/danda": "\u0964",
+ "/dango": "\u1F361",
+ "/darga:hb": "\u05A7",
+ "/dargahebrew": "\u05A7",
+ "/dargalefthebrew": "\u05A7",
+ "/darkShade": "\u2593",
+ "/darkSunglasses": "\u1F576",
+ "/dashwithupturnleft": "\u2E43",
+ "/dasiacmbcyr": "\u0485",
+ "/dasiapneumatacyrilliccmb": "\u0485",
+ "/dateseparator": "\u060D",
+ "/dayeighteentelegraph": "\u33F1",
+ "/dayeighttelegraph": "\u33E7",
+ "/dayeleventelegraph": "\u33EA",
+ "/dayfifteentelegraph": "\u33EE",
+ "/dayfivetelegraph": "\u33E4",
+ "/dayfourteentelegraph": "\u33ED",
+ "/dayfourtelegraph": "\u33E3",
+ "/daynineteentelegraph": "\u33F2",
+ "/dayninetelegraph": "\u33E8",
+ "/dayonetelegraph": "\u33E0",
+ "/dayseventeentelegraph": "\u33F0",
+ "/dayseventelegraph": "\u33E6",
+ "/daysixteentelegraph": "\u33EF",
+ "/daysixtelegraph": "\u33E5",
+ "/daytentelegraph": "\u33E9",
+ "/daythirteentelegraph": "\u33EC",
+ "/daythirtyonetelegraph": "\u33FE",
+ "/daythirtytelegraph": "\u33FD",
+ "/daythreetelegraph": "\u33E2",
+ "/daytwelvetelegraph": "\u33EB",
+ "/daytwentyeighttelegraph": "\u33FB",
+ "/daytwentyfivetelegraph": "\u33F8",
+ "/daytwentyfourtelegraph": "\u33F7",
+ "/daytwentyninetelegraph": "\u33FC",
+ "/daytwentyonetelegraph": "\u33F4",
+ "/daytwentyseventelegraph": "\u33FA",
+ "/daytwentysixtelegraph": "\u33F9",
+ "/daytwentytelegraph": "\u33F3",
+ "/daytwentythreetelegraph": "\u33F6",
+ "/daytwentytwotelegraph": "\u33F5",
+ "/daytwotelegraph": "\u33E1",
+ "/dbdigraph": "\u0238",
+ "/dbfullwidth": "\u33C8",
+ "/dblGrave": "\uF6D3",
+ "/dblanglebracketleft": "\u300A",
+ "/dblanglebracketleftvertical": "\uFE3D",
+ "/dblanglebracketright": "\u300B",
+ "/dblanglebracketrightvertical": "\uFE3E",
+ "/dblarchinvertedbelowcmb": "\u032B",
+ "/dblarrowNE": "\u21D7",
+ "/dblarrowNW": "\u21D6",
+ "/dblarrowSE": "\u21D8",
+ "/dblarrowSW": "\u21D9",
+ "/dblarrowdown": "\u21D3",
+ "/dblarrowleft": "\u21D4",
+ "/dblarrowleftright": "\u21D4",
+ "/dblarrowleftrightstroke": "\u21CE",
+ "/dblarrowleftstroke": "\u21CD",
+ "/dblarrowright": "\u21D2",
+ "/dblarrowrightstroke": "\u21CF",
+ "/dblarrowup": "\u21D1",
+ "/dblarrowupdown": "\u21D5",
+ "/dbldanda": "\u0965",
+ "/dbldnhorz": "\u2566",
+ "/dbldnleft": "\u2557",
+ "/dbldnright": "\u2554",
+ "/dblgrave": "\uF6D6",
+ "/dblgravecmb": "\u030F",
+ "/dblhorz": "\u2550",
+ "/dblintegral": "\u222C",
+ "/dbllowline": "\u2017",
+ "/dbllowlinecmb": "\u0333",
+ "/dbloverlinecmb": "\u033F",
+ "/dblprimemod": "\u02BA",
+ "/dblstrokearrowdown": "\u21DF",
+ "/dblstrokearrowup": "\u21DE",
+ "/dbluphorz": "\u2569",
+ "/dblupleft": "\u255D",
+ "/dblupright": "\u255A",
+ "/dblvert": "\u2551",
+ "/dblverthorz": "\u256C",
+ "/dblverticalbar": "\u2016",
+ "/dblverticallineabovecmb": "\u030E",
+ "/dblvertleft": "\u2563",
+ "/dblvertright": "\u2560",
+ "/dbopomofo": "\u3109",
+ "/dbsquare": "\u33C8",
+ "/dcaron": "\u010F",
+ "/dcedilla": "\u1E11",
+ "/dchecyr": "\u052D",
+ "/dcircle": "\u24D3",
+ "/dcircumflexbelow": "\u1E13",
+ "/dcroat": "\u0111",
+ "/dcurl": "\u0221",
+ "/ddabengali": "\u09A1",
+ "/ddadeva": "\u0921",
+ "/ddagujarati": "\u0AA1",
+ "/ddagurmukhi": "\u0A21",
+ "/ddahal": "\u068D",
+ "/ddahal.fina": "\uFB83",
+ "/ddahal.isol": "\uFB82",
+ "/ddal": "\u0688",
+ "/ddal.fina": "\uFB89",
+ "/ddal.isol": "\uFB88",
+ "/ddalarabic": "\u0688",
+ "/ddalfinalarabic": "\uFB89",
+ "/ddamahaprana": "\uA99E",
+ "/ddblstruckitalic": "\u2146",
+ "/dddhadeva": "\u095C",
+ "/ddhabengali": "\u09A2",
+ "/ddhadeva": "\u0922",
+ "/ddhagujarati": "\u0AA2",
+ "/ddhagurmukhi": "\u0A22",
+ "/ddot": "\u1E0B",
+ "/ddotaccent": "\u1E0B",
+ "/ddotbelow": "\u1E0D",
+ "/decembertelegraph": "\u32CB",
+ "/deciduousTree": "\u1F333",
+ "/decimalexponent": "\u23E8",
+ "/decimalseparatorarabic": "\u066B",
+ "/decimalseparatorpersian": "\u066B",
+ "/decreaseFontSize": "\u1F5DB",
+ "/decyr": "\u0434",
+ "/decyrillic": "\u0434",
+ "/degree": "\u00B0",
+ "/degreecelsius": "\u2103",
+ "/degreefahrenheit": "\u2109",
+ "/dehi:hb": "\u05AD",
+ "/dehihebrew": "\u05AD",
+ "/dehiragana": "\u3067",
+ "/deicoptic": "\u03EF",
+ "/dekatakana": "\u30C7",
+ "/dekomicyr": "\u0501",
+ "/deldiaeresisfunc": "\u2362",
+ "/deleteleft": "\u232B",
+ "/deleteright": "\u2326",
+ "/deliveryTruck": "\u1F69A",
+ "/delstilefunc": "\u2352",
+ "/delta": "\u03B4",
+ "/deltaequal": "\u225C",
+ "/deltastilefunc": "\u234B",
+ "/deltaturned": "\u018D",
+ "/deltaunderlinefunc": "\u2359",
+ "/deltildefunc": "\u236B",
+ "/denominatorminusonenumeratorbengali": "\u09F8",
+ "/dentistrybottomverticalleft": "\u23CC",
+ "/dentistrybottomverticalright": "\u23BF",
+ "/dentistrycircledownhorizontal": "\u23C1",
+ "/dentistrycircleuphorizontal": "\u23C2",
+ "/dentistrycirclevertical": "\u23C0",
+ "/dentistrydownhorizontal": "\u23C9",
+ "/dentistrytopverticalleft": "\u23CB",
+ "/dentistrytopverticalright": "\u23BE",
+ "/dentistrytriangledownhorizontal": "\u23C4",
+ "/dentistrytriangleuphorizontal": "\u23C5",
+ "/dentistrytrianglevertical": "\u23C3",
+ "/dentistryuphorizontal": "\u23CA",
+ "/dentistrywavedownhorizontal": "\u23C7",
+ "/dentistrywaveuphorizontal": "\u23C8",
+ "/dentistrywavevertical": "\u23C6",
+ "/departmentStore": "\u1F3EC",
+ "/derelictHouseBuilding": "\u1F3DA",
+ "/desert": "\u1F3DC",
+ "/desertIsland": "\u1F3DD",
+ "/desisquare": "\u3325",
+ "/desktopComputer": "\u1F5A5",
+ "/desktopWindow": "\u1F5D4",
+ "/deva:a": "\u0905",
+ "/deva:aa": "\u0906",
+ "/deva:aasign": "\u093E",
+ "/deva:abbreviation": "\u0970",
+ "/deva:acandra": "\u0972",
+ "/deva:acute": "\u0954",
+ "/deva:ai": "\u0910",
+ "/deva:aisign": "\u0948",
+ "/deva:anudatta": "\u0952",
+ "/deva:anusvara": "\u0902",
+ "/deva:ashort": "\u0904",
+ "/deva:au": "\u0914",
+ "/deva:ausign": "\u094C",
+ "/deva:avagraha": "\u093D",
+ "/deva:aw": "\u0975",
+ "/deva:awsign": "\u094F",
+ "/deva:ba": "\u092C",
+ "/deva:bba": "\u097F",
+ "/deva:bha": "\u092D",
+ "/deva:ca": "\u091A",
+ "/deva:candrabindu": "\u0901",
+ "/deva:candrabinduinverted": "\u0900",
+ "/deva:cha": "\u091B",
+ "/deva:da": "\u0926",
+ "/deva:danda": "\u0964",
+ "/deva:dbldanda": "\u0965",
+ "/deva:dda": "\u0921",
+ "/deva:ddda": "\u097E",
+ "/deva:dddha": "\u095C",
+ "/deva:ddha": "\u0922",
+ "/deva:dha": "\u0927",
+ "/deva:dothigh": "\u0971",
+ "/deva:e": "\u090F",
+ "/deva:ecandra": "\u090D",
+ "/deva:eight": "\u096E",
+ "/deva:eshort": "\u090E",
+ "/deva:esign": "\u0947",
+ "/deva:esigncandra": "\u0945",
+ "/deva:esignprishthamatra": "\u094E",
+ "/deva:esignshort": "\u0946",
+ "/deva:fa": "\u095E",
+ "/deva:five": "\u096B",
+ "/deva:four": "\u096A",
+ "/deva:ga": "\u0917",
+ "/deva:gga": "\u097B",
+ "/deva:gha": "\u0918",
+ "/deva:ghha": "\u095A",
+ "/deva:glottalstop": "\u097D",
+ "/deva:grave": "\u0953",
+ "/deva:ha": "\u0939",
+ "/deva:i": "\u0907",
+ "/deva:ii": "\u0908",
+ "/deva:iisign": "\u0940",
+ "/deva:isign": "\u093F",
+ "/deva:ja": "\u091C",
+ "/deva:jha": "\u091D",
+ "/deva:jja": "\u097C",
+ "/deva:ka": "\u0915",
+ "/deva:kha": "\u0916",
+ "/deva:khha": "\u0959",
+ "/deva:la": "\u0932",
+ "/deva:lla": "\u0933",
+ "/deva:llla": "\u0934",
+ "/deva:llvocal": "\u0961",
+ "/deva:llvocalsign": "\u0963",
+ "/deva:lvocal": "\u090C",
+ "/deva:lvocalsign": "\u0962",
+ "/deva:ma": "\u092E",
+ "/deva:marwaridda": "\u0978",
+ "/deva:na": "\u0928",
+ "/deva:nga": "\u0919",
+ "/deva:nine": "\u096F",
+ "/deva:nna": "\u0923",
+ "/deva:nnna": "\u0929",
+ "/deva:nukta": "\u093C",
+ "/deva:nya": "\u091E",
+ "/deva:o": "\u0913",
+ "/deva:ocandra": "\u0911",
+ "/deva:oe": "\u0973",
+ "/deva:oesign": "\u093A",
+ "/deva:om": "\u0950",
+ "/deva:one": "\u0967",
+ "/deva:ooe": "\u0974",
+ "/deva:ooesign": "\u093B",
+ "/deva:oshort": "\u0912",
+ "/deva:osign": "\u094B",
+ "/deva:osigncandra": "\u0949",
+ "/deva:osignshort": "\u094A",
+ "/deva:pa": "\u092A",
+ "/deva:pha": "\u092B",
+ "/deva:qa": "\u0958",
+ "/deva:ra": "\u0930",
+ "/deva:rha": "\u095D",
+ "/deva:rra": "\u0931",
+ "/deva:rrvocal": "\u0960",
+ "/deva:rrvocalsign": "\u0944",
+ "/deva:rvocal": "\u090B",
+ "/deva:rvocalsign": "\u0943",
+ "/deva:sa": "\u0938",
+ "/deva:seven": "\u096D",
+ "/deva:sha": "\u0936",
+ "/deva:signelongcandra": "\u0955",
+ "/deva:six": "\u096C",
+ "/deva:ssa": "\u0937",
+ "/deva:ta": "\u0924",
+ "/deva:tha": "\u0925",
+ "/deva:three": "\u0969",
+ "/deva:tta": "\u091F",
+ "/deva:ttha": "\u0920",
+ "/deva:two": "\u0968",
+ "/deva:u": "\u0909",
+ "/deva:udatta": "\u0951",
+ "/deva:ue": "\u0976",
+ "/deva:uesign": "\u0956",
+ "/deva:usign": "\u0941",
+ "/deva:uu": "\u090A",
+ "/deva:uue": "\u0977",
+ "/deva:uuesign": "\u0957",
+ "/deva:uusign": "\u0942",
+ "/deva:va": "\u0935",
+ "/deva:virama": "\u094D",
+ "/deva:visarga": "\u0903",
+ "/deva:ya": "\u092F",
+ "/deva:yaheavy": "\u097A",
+ "/deva:yya": "\u095F",
+ "/deva:za": "\u095B",
+ "/deva:zero": "\u0966",
+ "/deva:zha": "\u0979",
+ "/dezh": "\u02A4",
+ "/dfemaledbl": "\u26A2",
+ "/dhabengali": "\u09A7",
+ "/dhadeva": "\u0927",
+ "/dhagujarati": "\u0AA7",
+ "/dhagurmukhi": "\u0A27",
+ "/dhook": "\u0257",
+ "/diaeresisgreaterfunc": "\u2369",
+ "/dialytikatonos": "\u0385",
+ "/dialytikatonoscmb": "\u0344",
+ "/diametersign": "\u2300",
+ "/diamond": "\u2666",
+ "/diamondShapeADotInside": "\u1F4A0",
+ "/diamondinsquarewhite": "\u26CB",
+ "/diamondoperator": "\u22C4",
+ "/diamondsuitwhite": "\u2662",
+ "/diamondunderlinefunc": "\u235A",
+ "/diamondwhitewithdiamondsmallblack": "\u25C8",
+ "/diefive": "\u2684",
+ "/diefour": "\u2683",
+ "/dieone": "\u2680",
+ "/dieresis": "\u00A8",
+ "/dieresisacute": "\uF6D7",
+ "/dieresisbelowcmb": "\u0324",
+ "/dieresiscmb": "\u0308",
+ "/dieresisgrave": "\uF6D8",
+ "/dieresistilde": "\u1FC1",
+ "/dieresistonos": "\u0385",
+ "/dieselLocomotive": "\u1F6F2",
+ "/diesix": "\u2685",
+ "/diethree": "\u2682",
+ "/dietwo": "\u2681",
+ "/differencebetween": "\u224F",
+ "/digamma": "\u03DD",
+ "/digammapamphylian": "\u0377",
+ "/digramgreateryang": "\u268C",
+ "/digramgreateryin": "\u268F",
+ "/digramlesseryang": "\u268E",
+ "/digramlesseryin": "\u268D",
+ "/dihiragana": "\u3062",
+ "/dikatakana": "\u30C2",
+ "/dimensionorigin": "\u2331",
+ "/dingbatSAns-serifzerocircle": "\u1F10B",
+ "/dingbatSAns-serifzerocircleblack": "\u1F10C",
+ "/dinsular": "\uA77A",
+ "/directHit": "\u1F3AF",
+ "/directcurrentformtwo": "\u2393",
+ "/dirgamurevowel": "\uA9BB",
+ "/disabledcar": "\u26CD",
+ "/disappointedButRelievedFace": "\u1F625",
+ "/disappointedFace": "\u1F61E",
+ "/discontinuousunderline": "\u2382",
+ "/dittomark": "\u3003",
+ "/divide": "\u00F7",
+ "/divides": "\u2223",
+ "/divisionslash": "\u2215",
+ "/divisiontimes": "\u22C7",
+ "/divorce": "\u26AE",
+ "/dizzy": "\u1F4AB",
+ "/dizzyFace": "\u1F635",
+ "/djecyr": "\u0452",
+ "/djecyrillic": "\u0452",
+ "/djekomicyr": "\u0503",
+ "/dkshade": "\u2593",
+ "/dlfullwidth": "\u3397",
+ "/dlinebelow": "\u1E0F",
+ "/dlogicalorsquare": "\u27CF",
+ "/dlogicalsquare": "\u27CE",
+ "/dlsquare": "\u3397",
+ "/dm2fullwidth": "\u3378",
+ "/dm3fullwidth": "\u3379",
+ "/dmacron": "\u0111",
+ "/dmaledbl": "\u26A3",
+ "/dmfullwidth": "\u3377",
+ "/dmonospace": "\uFF44",
+ "/dnblock": "\u2584",
+ "/dndblhorzsng": "\u2565",
+ "/dndblleftsng": "\u2556",
+ "/dndblrightsng": "\u2553",
+ "/dngb:airplane": "\u2708",
+ "/dngb:arrowfeatheredblackNE": "\u27B6",
+ "/dngb:arrowfeatheredblackSE": "\u27B4",
+ "/dngb:arrowfeatheredblackheavyNE": "\u27B9",
+ "/dngb:arrowfeatheredblackheavySE": "\u27B7",
+ "/dngb:arrowheadrightblack": "\u27A4",
+ "/dngb:arrowheadrightthreeDbottomlight": "\u27A3",
+ "/dngb:arrowheadrightthreeDtoplight": "\u27A2",
+ "/dngb:arrowheavyNE": "\u279A",
+ "/dngb:arrowheavySE": "\u2798",
+ "/dngb:arrowrightbacktiltedshadowedwhite": "\u27AB",
+ "/dngb:arrowrightblack": "\u27A1",
+ "/dngb:arrowrightcircledwhiteheavy": "\u27B2",
+ "/dngb:arrowrightcurvedownblackheavy": "\u27A5",
+ "/dngb:arrowrightcurveupblackheavy": "\u27A6",
+ "/dngb:arrowrightfeatheredblack": "\u27B5",
+ "/dngb:arrowrightfeatheredblackheavy": "\u27B8",
+ "/dngb:arrowrightfeatheredwhite": "\u27B3",
+ "/dngb:arrowrightfronttiltedshadowedwhite": "\u27AC",
+ "/dngb:arrowrightheavy": "\u2799",
+ "/dngb:arrowrightleftshadedwhite": "\u27AA",
+ "/dngb:arrowrightoutlinedopen": "\u27BE",
+ "/dngb:arrowrightpointed": "\u279B",
+ "/dngb:arrowrightpointedblackheavy": "\u27A8",
+ "/dngb:arrowrightrightshadedwhite": "\u27A9",
+ "/dngb:arrowrightroundheavy": "\u279C",
+ "/dngb:arrowrightsquatblack": "\u27A7",
+ "/dngb:arrowrighttriangle": "\u279D",
+ "/dngb:arrowrighttriangledashed": "\u279F",
+ "/dngb:arrowrighttriangledashedheavy": "\u27A0",
+ "/dngb:arrowrighttriangleheavy": "\u279E",
+ "/dngb:arrowrightwedge": "\u27BC",
+ "/dngb:arrowrightwedgeheavy": "\u27BD",
+ "/dngb:arrowrightwideheavy": "\u2794",
+ "/dngb:arrowshadowrightlowerwhiteheavy": "\u27AD",
+ "/dngb:arrowshadowrightnotchedlowerwhite": "\u27AF",
+ "/dngb:arrowshadowrightnotchedupperwhite": "\u27B1",
+ "/dngb:arrowshadowrightupperwhiteheavy": "\u27AE",
+ "/dngb:arrowteardropright": "\u27BA",
+ "/dngb:arrowteardroprightheavy": "\u27BB",
+ "/dngb:asteriskballoon": "\u2749",
+ "/dngb:asteriskballoonfour": "\u2723",
+ "/dngb:asteriskballoonheavyfour": "\u2724",
+ "/dngb:asteriskcentreopen": "\u2732",
+ "/dngb:asteriskclubfour": "\u2725",
+ "/dngb:asteriskheavy": "\u2731",
+ "/dngb:asteriskpointedsixteen": "\u273A",
+ "/dngb:asteriskteardrop": "\u273B",
+ "/dngb:asteriskteardropcentreopen": "\u273C",
+ "/dngb:asteriskteardropfour": "\u2722",
+ "/dngb:asteriskteardropheavy": "\u273D",
+ "/dngb:asteriskteardroppinwheelheavy": "\u2743",
+ "/dngb:asteriskteardroppropellereight": "\u274A",
+ "/dngb:asteriskteardroppropellerheavyeight": "\u274B",
+ "/dngb:ballotx": "\u2717",
+ "/dngb:ballotxheavy": "\u2718",
+ "/dngb:bracketleftpointedangleheavyornament": "\u2770",
+ "/dngb:bracketleftpointedanglemediumornament": "\u276C",
+ "/dngb:bracketrightpointedangleheavyornament": "\u2771",
+ "/dngb:bracketrightpointedanglemediumornament": "\u276D",
+ "/dngb:bracketshellleftlightornament": "\u2772",
+ "/dngb:bracketshellrightlightornament": "\u2773",
+ "/dngb:check": "\u2713",
+ "/dngb:checkheavy": "\u2714",
+ "/dngb:checkwhiteheavy": "\u2705",
+ "/dngb:chevronsnowflakeheavy": "\u2746",
+ "/dngb:circleshadowedwhite": "\u274D",
+ "/dngb:commaheavydoubleornament": "\u275E",
+ "/dngb:commaheavydoubleturnedornament": "\u275D",
+ "/dngb:commaheavyornament": "\u275C",
+ "/dngb:commaheavyturnedornament": "\u275B",
+ "/dngb:compasstarpointedblackeight": "\u2737",
+ "/dngb:compasstarpointedblackheavyeight": "\u2738",
+ "/dngb:cross": "\u274C",
+ "/dngb:crosscentreopen": "\u271B",
+ "/dngb:crosscentreopenheavy": "\u271C",
+ "/dngb:curlybracketleftmediumornament": "\u2774",
+ "/dngb:curlybracketrightmediumornament": "\u2775",
+ "/dngb:curlyloop": "\u27B0",
+ "/dngb:curlyloopdouble": "\u27BF",
+ "/dngb:curvedstemparagraphsignornament": "\u2761",
+ "/dngb:diamondminusxblackwhite": "\u2756",
+ "/dngb:divisionsignheavy": "\u2797",
+ "/dngb:eightnegativecircled": "\u277D",
+ "/dngb:eightsanscircled": "\u2787",
+ "/dngb:eightsansnegativecircled": "\u2791",
+ "/dngb:envelope": "\u2709",
+ "/dngb:exclamationheavy": "\u2757",
+ "/dngb:exclamationheavyornament": "\u2762",
+ "/dngb:exclamationwhiteornament": "\u2755",
+ "/dngb:fivenegativecircled": "\u277A",
+ "/dngb:fivesanscircled": "\u2784",
+ "/dngb:fivesansnegativecircled": "\u278E",
+ "/dngb:floralheart": "\u2766",
+ "/dngb:floralheartbulletrotated": "\u2767",
+ "/dngb:floretteblack": "\u273F",
+ "/dngb:floretteoutlinedpetalledblackeight": "\u2741",
+ "/dngb:florettepetalledblackwhitesix": "\u273E",
+ "/dngb:florettewhite": "\u2740",
+ "/dngb:fournegativecircled": "\u2779",
+ "/dngb:foursanscircled": "\u2783",
+ "/dngb:foursansnegativecircled": "\u278D",
+ "/dngb:greekcrossheavy": "\u271A",
+ "/dngb:greekcrossoutlined": "\u2719",
+ "/dngb:heartblackheavy": "\u2764",
+ "/dngb:heartbulletrotatedblackheavy": "\u2765",
+ "/dngb:heartexclamationheavyornament": "\u2763",
+ "/dngb:hvictory": "\u270C",
+ "/dngb:hwriting": "\u270D",
+ "/dngb:latincross": "\u271D",
+ "/dngb:latincrossoutlined": "\u271F",
+ "/dngb:latincrossshadowedwhite": "\u271E",
+ "/dngb:lowcommaheavydoubleornament": "\u2760",
+ "/dngb:lowcommaheavyornament": "\u275F",
+ "/dngb:maltesecross": "\u2720",
+ "/dngb:minussignheavy": "\u2796",
+ "/dngb:multiplicationx": "\u2715",
+ "/dngb:multiplicationxheavy": "\u2716",
+ "/dngb:nibblack": "\u2712",
+ "/dngb:nibwhite": "\u2711",
+ "/dngb:ninenegativecircled": "\u277E",
+ "/dngb:ninesanscircled": "\u2788",
+ "/dngb:ninesansnegativecircled": "\u2792",
+ "/dngb:onenegativecircled": "\u2776",
+ "/dngb:onesanscircled": "\u2780",
+ "/dngb:onesansnegativecircled": "\u278A",
+ "/dngb:parenthesisleftflattenedmediumornament": "\u276A",
+ "/dngb:parenthesisleftmediumornament": "\u2768",
+ "/dngb:parenthesisrightflattenedmediumornament": "\u276B",
+ "/dngb:parenthesisrightmediumornament": "\u2769",
+ "/dngb:pencil": "\u270F",
+ "/dngb:pencillowerright": "\u270E",
+ "/dngb:pencilupperright": "\u2710",
+ "/dngb:plussignheavy": "\u2795",
+ "/dngb:questionblackornament": "\u2753",
+ "/dngb:questionwhiteornament": "\u2754",
+ "/dngb:quotationleftpointedangleheavyornament": "\u276E",
+ "/dngb:quotationrightpointedangleheavyornament": "\u276F",
+ "/dngb:raisedfist": "\u270A",
+ "/dngb:raisedh": "\u270B",
+ "/dngb:safetyscissorsblack": "\u2700",
+ "/dngb:scissorsblack": "\u2702",
+ "/dngb:scissorslowerblade": "\u2703",
+ "/dngb:scissorsupperblade": "\u2701",
+ "/dngb:scissorswhite": "\u2704",
+ "/dngb:sevennegativecircled": "\u277C",
+ "/dngb:sevensanscircled": "\u2786",
+ "/dngb:sevensansnegativecircled": "\u2790",
+ "/dngb:sixnegativecircled": "\u277B",
+ "/dngb:sixsanscircled": "\u2785",
+ "/dngb:sixsansnegativecircled": "\u278F",
+ "/dngb:snowflake": "\u2744",
+ "/dngb:snowflaketight": "\u2745",
+ "/dngb:sparkle": "\u2747",
+ "/dngb:sparkleheavy": "\u2748",
+ "/dngb:sparkles": "\u2728",
+ "/dngb:spokedasteriskeight": "\u2733",
+ "/dngb:squaredcrossnegative": "\u274E",
+ "/dngb:squarelowerrightshadowedwhite": "\u2751",
+ "/dngb:squareshadowlowerrightwhite": "\u274F",
+ "/dngb:squareshadowupperrightwhite": "\u2750",
+ "/dngb:squareupperrightshadowedwhite": "\u2752",
+ "/dngb:starcentreblackwhite": "\u272C",
+ "/dngb:starcentreopenblack": "\u272B",
+ "/dngb:starcentreopenpointedcircledeight": "\u2742",
+ "/dngb:starcircledwhite": "\u272A",
+ "/dngb:starofdavid": "\u2721",
+ "/dngb:staroutlinedblack": "\u272D",
+ "/dngb:staroutlinedblackheavy": "\u272E",
+ "/dngb:staroutlinedstresswhite": "\u2729",
+ "/dngb:starpinwheel": "\u272F",
+ "/dngb:starpointedblackeight": "\u2734",
+ "/dngb:starpointedblackfour": "\u2726",
+ "/dngb:starpointedblacksix": "\u2736",
+ "/dngb:starpointedblacktwelve": "\u2739",
+ "/dngb:starpointedpinwheeleight": "\u2735",
+ "/dngb:starpointedwhitefour": "\u2727",
+ "/dngb:starshadowedwhite": "\u2730",
+ "/dngb:tapedrive": "\u2707",
+ "/dngb:telephonelocationsign": "\u2706",
+ "/dngb:tennegativecircled": "\u277F",
+ "/dngb:tensanscircled": "\u2789",
+ "/dngb:tensansnegativecircled": "\u2793",
+ "/dngb:threenegativecircled": "\u2778",
+ "/dngb:threesanscircled": "\u2782",
+ "/dngb:threesansnegativecircled": "\u278C",
+ "/dngb:twonegativecircled": "\u2777",
+ "/dngb:twosanscircled": "\u2781",
+ "/dngb:twosansnegativecircled": "\u278B",
+ "/dngb:verticalbarheavy": "\u275A",
+ "/dngb:verticalbarlight": "\u2758",
+ "/dngb:verticalbarmedium": "\u2759",
+ "/dnheavyhorzlight": "\u2530",
+ "/dnheavyleftlight": "\u2512",
+ "/dnheavyleftuplight": "\u2527",
+ "/dnheavyrightlight": "\u250E",
+ "/dnheavyrightuplight": "\u251F",
+ "/dnheavyuphorzlight": "\u2541",
+ "/dnlighthorzheavy": "\u252F",
+ "/dnlightleftheavy": "\u2511",
+ "/dnlightleftupheavy": "\u2529",
+ "/dnlightrightheavy": "\u250D",
+ "/dnlightrightupheavy": "\u2521",
+ "/dnlightuphorzheavy": "\u2547",
+ "/dnsnghorzdbl": "\u2564",
+ "/dnsngleftdbl": "\u2555",
+ "/dnsngrightdbl": "\u2552",
+ "/doNotLitter": "\u1F6AF",
+ "/dochadathai": "\u0E0E",
+ "/document": "\u1F5CE",
+ "/documentPicture": "\u1F5BB",
+ "/documentText": "\u1F5B9",
+ "/documentTextAndPicture": "\u1F5BA",
+ "/dodekthai": "\u0E14",
+ "/doesnotcontainasnormalsubgroorequalup": "\u22ED",
+ "/doesnotcontainasnormalsubgroup": "\u22EB",
+ "/doesnotdivide": "\u2224",
+ "/doesnotforce": "\u22AE",
+ "/doesnotprecede": "\u2280",
+ "/doesnotprecedeorequal": "\u22E0",
+ "/doesnotprove": "\u22AC",
+ "/doesnotsucceed": "\u2281",
+ "/doesnotsucceedorequal": "\u22E1",
+ "/dog": "\u1F415",
+ "/dogFace": "\u1F436",
+ "/dohiragana": "\u3069",
+ "/dokatakana": "\u30C9",
+ "/dollar": "\u0024",
+ "/dollarinferior": "\uF6E3",
+ "/dollarmonospace": "\uFF04",
+ "/dollaroldstyle": "\uF724",
+ "/dollarsmall": "\uFE69",
+ "/dollarsuperior": "\uF6E4",
+ "/dolphin": "\u1F42C",
+ "/dominohorizontal_00_00": "\u1F031",
+ "/dominohorizontal_00_01": "\u1F032",
+ "/dominohorizontal_00_02": "\u1F033",
+ "/dominohorizontal_00_03": "\u1F034",
+ "/dominohorizontal_00_04": "\u1F035",
+ "/dominohorizontal_00_05": "\u1F036",
+ "/dominohorizontal_00_06": "\u1F037",
+ "/dominohorizontal_01_00": "\u1F038",
+ "/dominohorizontal_01_01": "\u1F039",
+ "/dominohorizontal_01_02": "\u1F03A",
+ "/dominohorizontal_01_03": "\u1F03B",
+ "/dominohorizontal_01_04": "\u1F03C",
+ "/dominohorizontal_01_05": "\u1F03D",
+ "/dominohorizontal_01_06": "\u1F03E",
+ "/dominohorizontal_02_00": "\u1F03F",
+ "/dominohorizontal_02_01": "\u1F040",
+ "/dominohorizontal_02_02": "\u1F041",
+ "/dominohorizontal_02_03": "\u1F042",
+ "/dominohorizontal_02_04": "\u1F043",
+ "/dominohorizontal_02_05": "\u1F044",
+ "/dominohorizontal_02_06": "\u1F045",
+ "/dominohorizontal_03_00": "\u1F046",
+ "/dominohorizontal_03_01": "\u1F047",
+ "/dominohorizontal_03_02": "\u1F048",
+ "/dominohorizontal_03_03": "\u1F049",
+ "/dominohorizontal_03_04": "\u1F04A",
+ "/dominohorizontal_03_05": "\u1F04B",
+ "/dominohorizontal_03_06": "\u1F04C",
+ "/dominohorizontal_04_00": "\u1F04D",
+ "/dominohorizontal_04_01": "\u1F04E",
+ "/dominohorizontal_04_02": "\u1F04F",
+ "/dominohorizontal_04_03": "\u1F050",
+ "/dominohorizontal_04_04": "\u1F051",
+ "/dominohorizontal_04_05": "\u1F052",
+ "/dominohorizontal_04_06": "\u1F053",
+ "/dominohorizontal_05_00": "\u1F054",
+ "/dominohorizontal_05_01": "\u1F055",
+ "/dominohorizontal_05_02": "\u1F056",
+ "/dominohorizontal_05_03": "\u1F057",
+ "/dominohorizontal_05_04": "\u1F058",
+ "/dominohorizontal_05_05": "\u1F059",
+ "/dominohorizontal_05_06": "\u1F05A",
+ "/dominohorizontal_06_00": "\u1F05B",
+ "/dominohorizontal_06_01": "\u1F05C",
+ "/dominohorizontal_06_02": "\u1F05D",
+ "/dominohorizontal_06_03": "\u1F05E",
+ "/dominohorizontal_06_04": "\u1F05F",
+ "/dominohorizontal_06_05": "\u1F060",
+ "/dominohorizontal_06_06": "\u1F061",
+ "/dominohorizontalback": "\u1F030",
+ "/dominovertical_00_00": "\u1F063",
+ "/dominovertical_00_01": "\u1F064",
+ "/dominovertical_00_02": "\u1F065",
+ "/dominovertical_00_03": "\u1F066",
+ "/dominovertical_00_04": "\u1F067",
+ "/dominovertical_00_05": "\u1F068",
+ "/dominovertical_00_06": "\u1F069",
+ "/dominovertical_01_00": "\u1F06A",
+ "/dominovertical_01_01": "\u1F06B",
+ "/dominovertical_01_02": "\u1F06C",
+ "/dominovertical_01_03": "\u1F06D",
+ "/dominovertical_01_04": "\u1F06E",
+ "/dominovertical_01_05": "\u1F06F",
+ "/dominovertical_01_06": "\u1F070",
+ "/dominovertical_02_00": "\u1F071",
+ "/dominovertical_02_01": "\u1F072",
+ "/dominovertical_02_02": "\u1F073",
+ "/dominovertical_02_03": "\u1F074",
+ "/dominovertical_02_04": "\u1F075",
+ "/dominovertical_02_05": "\u1F076",
+ "/dominovertical_02_06": "\u1F077",
+ "/dominovertical_03_00": "\u1F078",
+ "/dominovertical_03_01": "\u1F079",
+ "/dominovertical_03_02": "\u1F07A",
+ "/dominovertical_03_03": "\u1F07B",
+ "/dominovertical_03_04": "\u1F07C",
+ "/dominovertical_03_05": "\u1F07D",
+ "/dominovertical_03_06": "\u1F07E",
+ "/dominovertical_04_00": "\u1F07F",
+ "/dominovertical_04_01": "\u1F080",
+ "/dominovertical_04_02": "\u1F081",
+ "/dominovertical_04_03": "\u1F082",
+ "/dominovertical_04_04": "\u1F083",
+ "/dominovertical_04_05": "\u1F084",
+ "/dominovertical_04_06": "\u1F085",
+ "/dominovertical_05_00": "\u1F086",
+ "/dominovertical_05_01": "\u1F087",
+ "/dominovertical_05_02": "\u1F088",
+ "/dominovertical_05_03": "\u1F089",
+ "/dominovertical_05_04": "\u1F08A",
+ "/dominovertical_05_05": "\u1F08B",
+ "/dominovertical_05_06": "\u1F08C",
+ "/dominovertical_06_00": "\u1F08D",
+ "/dominovertical_06_01": "\u1F08E",
+ "/dominovertical_06_02": "\u1F08F",
+ "/dominovertical_06_03": "\u1F090",
+ "/dominovertical_06_04": "\u1F091",
+ "/dominovertical_06_05": "\u1F092",
+ "/dominovertical_06_06": "\u1F093",
+ "/dominoverticalback": "\u1F062",
+ "/dong": "\u20AB",
+ "/door": "\u1F6AA",
+ "/dorusquare": "\u3326",
+ "/dot": "\u27D1",
+ "/dotaccent": "\u02D9",
+ "/dotaccentcmb": "\u0307",
+ "/dotbelowcmb": "\u0323",
+ "/dotbelowcomb": "\u0323",
+ "/dotkatakana": "\u30FB",
+ "/dotlessbeh": "\u066E",
+ "/dotlessfeh": "\u06A1",
+ "/dotlessi": "\u0131",
+ "/dotlessj": "\uF6BE",
+ "/dotlessjstroke": "\u025F",
+ "/dotlessjstrokehook": "\u0284",
+ "/dotlesskhahabove": "\u06E1",
+ "/dotlessqaf": "\u066F",
+ "/dotlower:hb": "\u05C5",
+ "/dotmath": "\u22C5",
+ "/dotminus": "\u2238",
+ "/dotplus": "\u2214",
+ "/dotraised": "\u2E33",
+ "/dots1": "\u2801",
+ "/dots12": "\u2803",
+ "/dots123": "\u2807",
+ "/dots1234": "\u280F",
+ "/dots12345": "\u281F",
+ "/dots123456": "\u283F",
+ "/dots1234567": "\u287F",
+ "/dots12345678": "\u28FF",
+ "/dots1234568": "\u28BF",
+ "/dots123457": "\u285F",
+ "/dots1234578": "\u28DF",
+ "/dots123458": "\u289F",
+ "/dots12346": "\u282F",
+ "/dots123467": "\u286F",
+ "/dots1234678": "\u28EF",
+ "/dots123468": "\u28AF",
+ "/dots12347": "\u284F",
+ "/dots123478": "\u28CF",
+ "/dots12348": "\u288F",
+ "/dots1235": "\u2817",
+ "/dots12356": "\u2837",
+ "/dots123567": "\u2877",
+ "/dots1235678": "\u28F7",
+ "/dots123568": "\u28B7",
+ "/dots12357": "\u2857",
+ "/dots123578": "\u28D7",
+ "/dots12358": "\u2897",
+ "/dots1236": "\u2827",
+ "/dots12367": "\u2867",
+ "/dots123678": "\u28E7",
+ "/dots12368": "\u28A7",
+ "/dots1237": "\u2847",
+ "/dots12378": "\u28C7",
+ "/dots1238": "\u2887",
+ "/dots124": "\u280B",
+ "/dots1245": "\u281B",
+ "/dots12456": "\u283B",
+ "/dots124567": "\u287B",
+ "/dots1245678": "\u28FB",
+ "/dots124568": "\u28BB",
+ "/dots12457": "\u285B",
+ "/dots124578": "\u28DB",
+ "/dots12458": "\u289B",
+ "/dots1246": "\u282B",
+ "/dots12467": "\u286B",
+ "/dots124678": "\u28EB",
+ "/dots12468": "\u28AB",
+ "/dots1247": "\u284B",
+ "/dots12478": "\u28CB",
+ "/dots1248": "\u288B",
+ "/dots125": "\u2813",
+ "/dots1256": "\u2833",
+ "/dots12567": "\u2873",
+ "/dots125678": "\u28F3",
+ "/dots12568": "\u28B3",
+ "/dots1257": "\u2853",
+ "/dots12578": "\u28D3",
+ "/dots1258": "\u2893",
+ "/dots126": "\u2823",
+ "/dots1267": "\u2863",
+ "/dots12678": "\u28E3",
+ "/dots1268": "\u28A3",
+ "/dots127": "\u2843",
+ "/dots1278": "\u28C3",
+ "/dots128": "\u2883",
+ "/dots13": "\u2805",
+ "/dots134": "\u280D",
+ "/dots1345": "\u281D",
+ "/dots13456": "\u283D",
+ "/dots134567": "\u287D",
+ "/dots1345678": "\u28FD",
+ "/dots134568": "\u28BD",
+ "/dots13457": "\u285D",
+ "/dots134578": "\u28DD",
+ "/dots13458": "\u289D",
+ "/dots1346": "\u282D",
+ "/dots13467": "\u286D",
+ "/dots134678": "\u28ED",
+ "/dots13468": "\u28AD",
+ "/dots1347": "\u284D",
+ "/dots13478": "\u28CD",
+ "/dots1348": "\u288D",
+ "/dots135": "\u2815",
+ "/dots1356": "\u2835",
+ "/dots13567": "\u2875",
+ "/dots135678": "\u28F5",
+ "/dots13568": "\u28B5",
+ "/dots1357": "\u2855",
+ "/dots13578": "\u28D5",
+ "/dots1358": "\u2895",
+ "/dots136": "\u2825",
+ "/dots1367": "\u2865",
+ "/dots13678": "\u28E5",
+ "/dots1368": "\u28A5",
+ "/dots137": "\u2845",
+ "/dots1378": "\u28C5",
+ "/dots138": "\u2885",
+ "/dots14": "\u2809",
+ "/dots145": "\u2819",
+ "/dots1456": "\u2839",
+ "/dots14567": "\u2879",
+ "/dots145678": "\u28F9",
+ "/dots14568": "\u28B9",
+ "/dots1457": "\u2859",
+ "/dots14578": "\u28D9",
+ "/dots1458": "\u2899",
+ "/dots146": "\u2829",
+ "/dots1467": "\u2869",
+ "/dots14678": "\u28E9",
+ "/dots1468": "\u28A9",
+ "/dots147": "\u2849",
+ "/dots1478": "\u28C9",
+ "/dots148": "\u2889",
+ "/dots15": "\u2811",
+ "/dots156": "\u2831",
+ "/dots1567": "\u2871",
+ "/dots15678": "\u28F1",
+ "/dots1568": "\u28B1",
+ "/dots157": "\u2851",
+ "/dots1578": "\u28D1",
+ "/dots158": "\u2891",
+ "/dots16": "\u2821",
+ "/dots167": "\u2861",
+ "/dots1678": "\u28E1",
+ "/dots168": "\u28A1",
+ "/dots17": "\u2841",
+ "/dots178": "\u28C1",
+ "/dots18": "\u2881",
+ "/dots2": "\u2802",
+ "/dots23": "\u2806",
+ "/dots234": "\u280E",
+ "/dots2345": "\u281E",
+ "/dots23456": "\u283E",
+ "/dots234567": "\u287E",
+ "/dots2345678": "\u28FE",
+ "/dots234568": "\u28BE",
+ "/dots23457": "\u285E",
+ "/dots234578": "\u28DE",
+ "/dots23458": "\u289E",
+ "/dots2346": "\u282E",
+ "/dots23467": "\u286E",
+ "/dots234678": "\u28EE",
+ "/dots23468": "\u28AE",
+ "/dots2347": "\u284E",
+ "/dots23478": "\u28CE",
+ "/dots2348": "\u288E",
+ "/dots235": "\u2816",
+ "/dots2356": "\u2836",
+ "/dots23567": "\u2876",
+ "/dots235678": "\u28F6",
+ "/dots23568": "\u28B6",
+ "/dots2357": "\u2856",
+ "/dots23578": "\u28D6",
+ "/dots2358": "\u2896",
+ "/dots236": "\u2826",
+ "/dots2367": "\u2866",
+ "/dots23678": "\u28E6",
+ "/dots2368": "\u28A6",
+ "/dots237": "\u2846",
+ "/dots2378": "\u28C6",
+ "/dots238": "\u2886",
+ "/dots24": "\u280A",
+ "/dots245": "\u281A",
+ "/dots2456": "\u283A",
+ "/dots24567": "\u287A",
+ "/dots245678": "\u28FA",
+ "/dots24568": "\u28BA",
+ "/dots2457": "\u285A",
+ "/dots24578": "\u28DA",
+ "/dots2458": "\u289A",
+ "/dots246": "\u282A",
+ "/dots2467": "\u286A",
+ "/dots24678": "\u28EA",
+ "/dots2468": "\u28AA",
+ "/dots247": "\u284A",
+ "/dots2478": "\u28CA",
+ "/dots248": "\u288A",
+ "/dots25": "\u2812",
+ "/dots256": "\u2832",
+ "/dots2567": "\u2872",
+ "/dots25678": "\u28F2",
+ "/dots2568": "\u28B2",
+ "/dots257": "\u2852",
+ "/dots2578": "\u28D2",
+ "/dots258": "\u2892",
+ "/dots26": "\u2822",
+ "/dots267": "\u2862",
+ "/dots2678": "\u28E2",
+ "/dots268": "\u28A2",
+ "/dots27": "\u2842",
+ "/dots278": "\u28C2",
+ "/dots28": "\u2882",
+ "/dots3": "\u2804",
+ "/dots34": "\u280C",
+ "/dots345": "\u281C",
+ "/dots3456": "\u283C",
+ "/dots34567": "\u287C",
+ "/dots345678": "\u28FC",
+ "/dots34568": "\u28BC",
+ "/dots3457": "\u285C",
+ "/dots34578": "\u28DC",
+ "/dots3458": "\u289C",
+ "/dots346": "\u282C",
+ "/dots3467": "\u286C",
+ "/dots34678": "\u28EC",
+ "/dots3468": "\u28AC",
+ "/dots347": "\u284C",
+ "/dots3478": "\u28CC",
+ "/dots348": "\u288C",
+ "/dots35": "\u2814",
+ "/dots356": "\u2834",
+ "/dots3567": "\u2874",
+ "/dots35678": "\u28F4",
+ "/dots3568": "\u28B4",
+ "/dots357": "\u2854",
+ "/dots3578": "\u28D4",
+ "/dots358": "\u2894",
+ "/dots36": "\u2824",
+ "/dots367": "\u2864",
+ "/dots3678": "\u28E4",
+ "/dots368": "\u28A4",
+ "/dots37": "\u2844",
+ "/dots378": "\u28C4",
+ "/dots38": "\u2884",
+ "/dots4": "\u2808",
+ "/dots45": "\u2818",
+ "/dots456": "\u2838",
+ "/dots4567": "\u2878",
+ "/dots45678": "\u28F8",
+ "/dots4568": "\u28B8",
+ "/dots457": "\u2858",
+ "/dots4578": "\u28D8",
+ "/dots458": "\u2898",
+ "/dots46": "\u2828",
+ "/dots467": "\u2868",
+ "/dots4678": "\u28E8",
+ "/dots468": "\u28A8",
+ "/dots47": "\u2848",
+ "/dots478": "\u28C8",
+ "/dots48": "\u2888",
+ "/dots5": "\u2810",
+ "/dots56": "\u2830",
+ "/dots567": "\u2870",
+ "/dots5678": "\u28F0",
+ "/dots568": "\u28B0",
+ "/dots57": "\u2850",
+ "/dots578": "\u28D0",
+ "/dots58": "\u2890",
+ "/dots6": "\u2820",
+ "/dots67": "\u2860",
+ "/dots678": "\u28E0",
+ "/dots68": "\u28A0",
+ "/dots7": "\u2840",
+ "/dots78": "\u28C0",
+ "/dots8": "\u2880",
+ "/dotsquarefour": "\u2E2C",
+ "/dottedcircle": "\u25CC",
+ "/dottedcross": "\u205C",
+ "/dotupper:hb": "\u05C4",
+ "/doublebarvertical": "\u23F8",
+ "/doubleyodpatah": "\uFB1F",
+ "/doubleyodpatahhebrew": "\uFB1F",
+ "/doughnut": "\u1F369",
+ "/doveOfPeace": "\u1F54A",
+ "/downtackbelowcmb": "\u031E",
+ "/downtackmod": "\u02D5",
+ "/downwarrowleftofuparrow": "\u21F5",
+ "/dparen": "\u249F",
+ "/dparenthesized": "\u249F",
+ "/drachma": "\u20AF",
+ "/dragon": "\u1F409",
+ "/dragonFace": "\u1F432",
+ "/draughtskingblack": "\u26C3",
+ "/draughtskingwhite": "\u26C1",
+ "/draughtsmanblack": "\u26C2",
+ "/draughtsmanwhite": "\u26C0",
+ "/dress": "\u1F457",
+ "/driveslow": "\u26DA",
+ "/dromedaryCamel": "\u1F42A",
+ "/droplet": "\u1F4A7",
+ "/dsquare": "\u1F1A5",
+ "/dsuperior": "\uF6EB",
+ "/dtail": "\u0256",
+ "/dtopbar": "\u018C",
+ "/duhiragana": "\u3065",
+ "/dukatakana": "\u30C5",
+ "/dul": "\u068E",
+ "/dul.fina": "\uFB87",
+ "/dul.isol": "\uFB86",
+ "/dum": "\uA771",
+ "/dvd": "\u1F4C0",
+ "/dyeh": "\u0684",
+ "/dyeh.fina": "\uFB73",
+ "/dyeh.init": "\uFB74",
+ "/dyeh.isol": "\uFB72",
+ "/dyeh.medi": "\uFB75",
+ "/dz": "\u01F3",
+ "/dzaltone": "\u02A3",
+ "/dzcaron": "\u01C6",
+ "/dzcurl": "\u02A5",
+ "/dzeabkhasiancyrillic": "\u04E1",
+ "/dzeabkhcyr": "\u04E1",
+ "/dzecyr": "\u0455",
+ "/dzecyrillic": "\u0455",
+ "/dzed": "\u02A3",
+ "/dzedcurl": "\u02A5",
+ "/dzhecyr": "\u045F",
+ "/dzhecyrillic": "\u045F",
+ "/dzjekomicyr": "\u0507",
+ "/dzzhecyr": "\u052B",
+ "/e": "\u0065",
+ "/e-mail": "\u1F4E7",
+ "/e.fina": "\uFBE5",
+ "/e.inferior": "\u2091",
+ "/e.init": "\uFBE6",
+ "/e.isol": "\uFBE4",
+ "/e.medi": "\uFBE7",
+ "/eVfullwidth": "\u32CE",
+ "/eacute": "\u00E9",
+ "/earOfMaize": "\u1F33D",
+ "/earOfRice": "\u1F33E",
+ "/earth": "\u2641",
+ "/earthGlobeAmericas": "\u1F30E",
+ "/earthGlobeAsiaAustralia": "\u1F30F",
+ "/earthGlobeEuropeAfrica": "\u1F30D",
+ "/earthground": "\u23DA",
+ "/earthideographiccircled": "\u328F",
+ "/earthideographicparen": "\u322F",
+ "/eastsyriaccross": "\u2671",
+ "/ebengali": "\u098F",
+ "/ebopomofo": "\u311C",
+ "/ebreve": "\u0115",
+ "/ecandradeva": "\u090D",
+ "/ecandragujarati": "\u0A8D",
+ "/ecandravowelsigndeva": "\u0945",
+ "/ecandravowelsigngujarati": "\u0AC5",
+ "/ecaron": "\u011B",
+ "/ecedilla": "\u0229",
+ "/ecedillabreve": "\u1E1D",
+ "/echarmenian": "\u0565",
+ "/echyiwnarmenian": "\u0587",
+ "/ecircle": "\u24D4",
+ "/ecirclekatakana": "\u32D3",
+ "/ecircumflex": "\u00EA",
+ "/ecircumflexacute": "\u1EBF",
+ "/ecircumflexbelow": "\u1E19",
+ "/ecircumflexdotbelow": "\u1EC7",
+ "/ecircumflexgrave": "\u1EC1",
+ "/ecircumflexhoi": "\u1EC3",
+ "/ecircumflexhookabove": "\u1EC3",
+ "/ecircumflextilde": "\u1EC5",
+ "/ecyrillic": "\u0454",
+ "/edblgrave": "\u0205",
+ "/edblstruckitalic": "\u2147",
+ "/edeva": "\u090F",
+ "/edieresis": "\u00EB",
+ "/edot": "\u0117",
+ "/edotaccent": "\u0117",
+ "/edotbelow": "\u1EB9",
+ "/eegurmukhi": "\u0A0F",
+ "/eekaasquare": "\u3308",
+ "/eematragurmukhi": "\u0A47",
+ "/efcyr": "\u0444",
+ "/efcyrillic": "\u0444",
+ "/egrave": "\u00E8",
+ "/egravedbl": "\u0205",
+ "/egujarati": "\u0A8F",
+ "/egyptain": "\uA725",
+ "/egyptalef": "\uA723",
+ "/eharmenian": "\u0567",
+ "/ehbopomofo": "\u311D",
+ "/ehiragana": "\u3048",
+ "/ehoi": "\u1EBB",
+ "/ehookabove": "\u1EBB",
+ "/eibopomofo": "\u311F",
+ "/eight": "\u0038",
+ "/eight.inferior": "\u2088",
+ "/eight.roman": "\u2167",
+ "/eight.romansmall": "\u2177",
+ "/eight.superior": "\u2078",
+ "/eightarabic": "\u0668",
+ "/eightbengali": "\u09EE",
+ "/eightcircle": "\u2467",
+ "/eightcircledbl": "\u24FC",
+ "/eightcircleinversesansserif": "\u2791",
+ "/eightcomma": "\u1F109",
+ "/eightdeva": "\u096E",
+ "/eighteencircle": "\u2471",
+ "/eighteencircleblack": "\u24F2",
+ "/eighteenparen": "\u2485",
+ "/eighteenparenthesized": "\u2485",
+ "/eighteenperiod": "\u2499",
+ "/eightfar": "\u06F8",
+ "/eightgujarati": "\u0AEE",
+ "/eightgurmukhi": "\u0A6E",
+ "/eighthackarabic": "\u0668",
+ "/eighthangzhou": "\u3028",
+ "/eighthnote": "\u266A",
+ "/eighthnotebeamed": "\u266B",
+ "/eightideographiccircled": "\u3287",
+ "/eightideographicparen": "\u3227",
+ "/eightinferior": "\u2088",
+ "/eightksquare": "\u1F19F",
+ "/eightmonospace": "\uFF18",
+ "/eightoldstyle": "\uF738",
+ "/eightparen": "\u247B",
+ "/eightparenthesized": "\u247B",
+ "/eightperiod": "\u248F",
+ "/eightpersian": "\u06F8",
+ "/eightroman": "\u2177",
+ "/eightsuperior": "\u2078",
+ "/eightthai": "\u0E58",
+ "/eightycirclesquare": "\u324F",
+ "/einvertedbreve": "\u0207",
+ "/eiotifiedcyr": "\u0465",
+ "/eiotifiedcyrillic": "\u0465",
+ "/eject": "\u23CF",
+ "/ekatakana": "\u30A8",
+ "/ekatakanahalfwidth": "\uFF74",
+ "/ekonkargurmukhi": "\u0A74",
+ "/ekorean": "\u3154",
+ "/elcyr": "\u043B",
+ "/elcyrillic": "\u043B",
+ "/electricLightBulb": "\u1F4A1",
+ "/electricPlug": "\u1F50C",
+ "/electricTorch": "\u1F526",
+ "/electricalintersection": "\u23E7",
+ "/electricarrow": "\u2301",
+ "/element": "\u2208",
+ "/elementdotabove": "\u22F5",
+ "/elementlonghorizontalstroke": "\u22F2",
+ "/elementopeningup": "\u27D2",
+ "/elementoverbar": "\u22F6",
+ "/elementoverbarsmall": "\u22F7",
+ "/elementsmall": "\u220A",
+ "/elementsmallverticalbarhorizontalstroke": "\u22F4",
+ "/elementtwoshorizontalstroke": "\u22F9",
+ "/elementunderbar": "\u22F8",
+ "/elementverticalbarhorizontalstroke": "\u22F3",
+ "/elephant": "\u1F418",
+ "/eleven.roman": "\u216A",
+ "/eleven.romansmall": "\u217A",
+ "/elevencircle": "\u246A",
+ "/elevencircleblack": "\u24EB",
+ "/elevenparen": "\u247E",
+ "/elevenparenthesized": "\u247E",
+ "/elevenperiod": "\u2492",
+ "/elevenroman": "\u217A",
+ "/elhookcyr": "\u0513",
+ "/ellipsis": "\u2026",
+ "/ellipsisdiagonaldownright": "\u22F1",
+ "/ellipsisdiagonalupright": "\u22F0",
+ "/ellipsismidhorizontal": "\u22EF",
+ "/ellipsisvertical": "\u22EE",
+ "/elmiddlehookcyr": "\u0521",
+ "/elsharptailcyr": "\u04C6",
+ "/eltailcyr": "\u052F",
+ "/emacron": "\u0113",
+ "/emacronacute": "\u1E17",
+ "/emacrongrave": "\u1E15",
+ "/emcyr": "\u043C",
+ "/emcyrillic": "\u043C",
+ "/emdash": "\u2014",
+ "/emdashdbl": "\u2E3A",
+ "/emdashtpl": "\u2E3B",
+ "/emdashvertical": "\uFE31",
+ "/emojiModifierFitzpatrickType-1-2": "\u1F3FB",
+ "/emojiModifierFitzpatrickType-3": "\u1F3FC",
+ "/emojiModifierFitzpatrickType-4": "\u1F3FD",
+ "/emojiModifierFitzpatrickType-5": "\u1F3FE",
+ "/emojiModifierFitzpatrickType-6": "\u1F3FF",
+ "/emonospace": "\uFF45",
+ "/emphasis": "\u2383",
+ "/emphasismarkarmenian": "\u055B",
+ "/emptyDocument": "\u1F5CB",
+ "/emptyNote": "\u1F5C5",
+ "/emptyNotePad": "\u1F5C7",
+ "/emptyNotePage": "\u1F5C6",
+ "/emptyPage": "\u1F5CC",
+ "/emptyPages": "\u1F5CD",
+ "/emptyset": "\u2205",
+ "/emquad": "\u2001",
+ "/emsharptailcyr": "\u04CE",
+ "/emspace": "\u2003",
+ "/enbopomofo": "\u3123",
+ "/encyr": "\u043D",
+ "/encyrillic": "\u043D",
+ "/endLeftwardsArrowAbove": "\u1F51A",
+ "/endash": "\u2013",
+ "/endashvertical": "\uFE32",
+ "/endescendercyrillic": "\u04A3",
+ "/endpro": "\u220E",
+ "/eng": "\u014B",
+ "/engbopomofo": "\u3125",
+ "/engecyr": "\u04A5",
+ "/enghecyrillic": "\u04A5",
+ "/enhookcyr": "\u04C8",
+ "/enhookcyrillic": "\u04C8",
+ "/enhookleftcyr": "\u0529",
+ "/enmiddlehookcyr": "\u0523",
+ "/enotch": "\u2C78",
+ "/enquad": "\u2000",
+ "/ensharptailcyr": "\u04CA",
+ "/enspace": "\u2002",
+ "/entailcyr": "\u04A3",
+ "/enter": "\u2386",
+ "/enterpriseideographiccircled": "\u32AD",
+ "/enterpriseideographicparen": "\u323D",
+ "/envelopeDownwardsArrowAbove": "\u1F4E9",
+ "/envelopeLightning": "\u1F584",
+ "/eogonek": "\u0119",
+ "/eokorean": "\u3153",
+ "/eopen": "\u025B",
+ "/eopenclosed": "\u029A",
+ "/eopenreversed": "\u025C",
+ "/eopenreversedclosed": "\u025E",
+ "/eopenreversedhook": "\u025D",
+ "/eparen": "\u24A0",
+ "/eparenthesized": "\u24A0",
+ "/epsilon": "\u03B5",
+ "/epsilonacute": "\u1F73",
+ "/epsilonasper": "\u1F11",
+ "/epsilonasperacute": "\u1F15",
+ "/epsilonaspergrave": "\u1F13",
+ "/epsilongrave": "\u1F72",
+ "/epsilonlenis": "\u1F10",
+ "/epsilonlenisacute": "\u1F14",
+ "/epsilonlenisgrave": "\u1F12",
+ "/epsilonlunatesymbol": "\u03F5",
+ "/epsilonreversedlunatesymbol": "\u03F6",
+ "/epsilontonos": "\u03AD",
+ "/epsilonunderlinefunc": "\u2377",
+ "/equal": "\u003D",
+ "/equal.inferior": "\u208C",
+ "/equal.superior": "\u207C",
+ "/equalandparallel": "\u22D5",
+ "/equalbydefinition": "\u225D",
+ "/equalmonospace": "\uFF1D",
+ "/equalorgreater": "\u22DD",
+ "/equalorless": "\u22DC",
+ "/equalorprecedes": "\u22DE",
+ "/equalorsucceeds": "\u22DF",
+ "/equalscolon": "\u2255",
+ "/equalsmall": "\uFE66",
+ "/equalsuperior": "\u207C",
+ "/equiangular": "\u225A",
+ "/equivalence": "\u2261",
+ "/equivalent": "\u224D",
+ "/eranameheiseisquare": "\u337B",
+ "/eranamemeizisquare": "\u337E",
+ "/eranamesyouwasquare": "\u337C",
+ "/eranametaisyousquare": "\u337D",
+ "/eraseleft": "\u232B",
+ "/eraseright": "\u2326",
+ "/erbopomofo": "\u3126",
+ "/ercyr": "\u0440",
+ "/ercyrillic": "\u0440",
+ "/ereversed": "\u0258",
+ "/ereversedcyr": "\u044D",
+ "/ereversedcyrillic": "\u044D",
+ "/ereverseddieresiscyr": "\u04ED",
+ "/ergfullwidth": "\u32CD",
+ "/ertickcyr": "\u048F",
+ "/escript": "\u212F",
+ "/escyr": "\u0441",
+ "/escyrillic": "\u0441",
+ "/esdescendercyrillic": "\u04AB",
+ "/esh": "\u0283",
+ "/eshcurl": "\u0286",
+ "/eshortdeva": "\u090E",
+ "/eshortvowelsigndeva": "\u0946",
+ "/eshreversedloop": "\u01AA",
+ "/eshsquatreversed": "\u0285",
+ "/esmallhiragana": "\u3047",
+ "/esmallkatakana": "\u30A7",
+ "/esmallkatakanahalfwidth": "\uFF6A",
+ "/estailcyr": "\u04AB",
+ "/estimated": "\u212E",
+ "/estimates": "\u2259",
+ "/estroke": "\u0247",
+ "/esukuudosquare": "\u3307",
+ "/esuperior": "\uF6EC",
+ "/et": "\uA76B",
+ "/eta": "\u03B7",
+ "/etaacute": "\u1F75",
+ "/etaacuteiotasub": "\u1FC4",
+ "/etaasper": "\u1F21",
+ "/etaasperacute": "\u1F25",
+ "/etaasperacuteiotasub": "\u1F95",
+ "/etaaspergrave": "\u1F23",
+ "/etaaspergraveiotasub": "\u1F93",
+ "/etaasperiotasub": "\u1F91",
+ "/etaaspertilde": "\u1F27",
+ "/etaaspertildeiotasub": "\u1F97",
+ "/etagrave": "\u1F74",
+ "/etagraveiotasub": "\u1FC2",
+ "/etaiotasub": "\u1FC3",
+ "/etalenis": "\u1F20",
+ "/etalenisacute": "\u1F24",
+ "/etalenisacuteiotasub": "\u1F94",
+ "/etalenisgrave": "\u1F22",
+ "/etalenisgraveiotasub": "\u1F92",
+ "/etalenisiotasub": "\u1F90",
+ "/etalenistilde": "\u1F26",
+ "/etalenistildeiotasub": "\u1F96",
+ "/etarmenian": "\u0568",
+ "/etatilde": "\u1FC6",
+ "/etatildeiotasub": "\u1FC7",
+ "/etatonos": "\u03AE",
+ "/eth": "\u00F0",
+ "/ethi:aaglottal": "\u12A3",
+ "/ethi:aglottal": "\u12A0",
+ "/ethi:ba": "\u1260",
+ "/ethi:baa": "\u1263",
+ "/ethi:be": "\u1265",
+ "/ethi:bee": "\u1264",
+ "/ethi:bi": "\u1262",
+ "/ethi:bo": "\u1266",
+ "/ethi:bu": "\u1261",
+ "/ethi:bwa": "\u1267",
+ "/ethi:ca": "\u1278",
+ "/ethi:caa": "\u127B",
+ "/ethi:ce": "\u127D",
+ "/ethi:cee": "\u127C",
+ "/ethi:cha": "\u1328",
+ "/ethi:chaa": "\u132B",
+ "/ethi:che": "\u132D",
+ "/ethi:chee": "\u132C",
+ "/ethi:chi": "\u132A",
+ "/ethi:cho": "\u132E",
+ "/ethi:chu": "\u1329",
+ "/ethi:chwa": "\u132F",
+ "/ethi:ci": "\u127A",
+ "/ethi:co": "\u127E",
+ "/ethi:colon": "\u1365",
+ "/ethi:comma": "\u1363",
+ "/ethi:cu": "\u1279",
+ "/ethi:cwa": "\u127F",
+ "/ethi:da": "\u12F0",
+ "/ethi:daa": "\u12F3",
+ "/ethi:dda": "\u12F8",
+ "/ethi:ddaa": "\u12FB",
+ "/ethi:dde": "\u12FD",
+ "/ethi:ddee": "\u12FC",
+ "/ethi:ddi": "\u12FA",
+ "/ethi:ddo": "\u12FE",
+ "/ethi:ddu": "\u12F9",
+ "/ethi:ddwa": "\u12FF",
+ "/ethi:de": "\u12F5",
+ "/ethi:dee": "\u12F4",
+ "/ethi:di": "\u12F2",
+ "/ethi:do": "\u12F6",
+ "/ethi:du": "\u12F1",
+ "/ethi:dwa": "\u12F7",
+ "/ethi:eeglottal": "\u12A4",
+ "/ethi:eglottal": "\u12A5",
+ "/ethi:eight": "\u1370",
+ "/ethi:eighty": "\u1379",
+ "/ethi:fa": "\u1348",
+ "/ethi:faa": "\u134B",
+ "/ethi:fe": "\u134D",
+ "/ethi:fee": "\u134C",
+ "/ethi:fi": "\u134A",
+ "/ethi:fifty": "\u1376",
+ "/ethi:five": "\u136D",
+ "/ethi:fo": "\u134E",
+ "/ethi:forty": "\u1375",
+ "/ethi:four": "\u136C",
+ "/ethi:fu": "\u1349",
+ "/ethi:fullstop": "\u1362",
+ "/ethi:fwa": "\u134F",
+ "/ethi:fya": "\u135A",
+ "/ethi:ga": "\u1308",
+ "/ethi:gaa": "\u130B",
+ "/ethi:ge": "\u130D",
+ "/ethi:gee": "\u130C",
+ "/ethi:geminationandvowellengthmarkcmb": "\u135D",
+ "/ethi:geminationmarkcmb": "\u135F",
+ "/ethi:gga": "\u1318",
+ "/ethi:ggaa": "\u131B",
+ "/ethi:gge": "\u131D",
+ "/ethi:ggee": "\u131C",
+ "/ethi:ggi": "\u131A",
+ "/ethi:ggo": "\u131E",
+ "/ethi:ggu": "\u1319",
+ "/ethi:ggwaa": "\u131F",
+ "/ethi:gi": "\u130A",
+ "/ethi:go": "\u130E",
+ "/ethi:goa": "\u130F",
+ "/ethi:gu": "\u1309",
+ "/ethi:gwa": "\u1310",
+ "/ethi:gwaa": "\u1313",
+ "/ethi:gwe": "\u1315",
+ "/ethi:gwee": "\u1314",
+ "/ethi:gwi": "\u1312",
+ "/ethi:ha": "\u1200",
+ "/ethi:haa": "\u1203",
+ "/ethi:he": "\u1205",
+ "/ethi:hee": "\u1204",
+ "/ethi:hha": "\u1210",
+ "/ethi:hhaa": "\u1213",
+ "/ethi:hhe": "\u1215",
+ "/ethi:hhee": "\u1214",
+ "/ethi:hhi": "\u1212",
+ "/ethi:hho": "\u1216",
+ "/ethi:hhu": "\u1211",
+ "/ethi:hhwa": "\u1217",
+ "/ethi:hi": "\u1202",
+ "/ethi:ho": "\u1206",
+ "/ethi:hoa": "\u1207",
+ "/ethi:hu": "\u1201",
+ "/ethi:hundred": "\u137B",
+ "/ethi:iglottal": "\u12A2",
+ "/ethi:ja": "\u1300",
+ "/ethi:jaa": "\u1303",
+ "/ethi:je": "\u1305",
+ "/ethi:jee": "\u1304",
+ "/ethi:ji": "\u1302",
+ "/ethi:jo": "\u1306",
+ "/ethi:ju": "\u1301",
+ "/ethi:jwa": "\u1307",
+ "/ethi:ka": "\u12A8",
+ "/ethi:kaa": "\u12AB",
+ "/ethi:ke": "\u12AD",
+ "/ethi:kee": "\u12AC",
+ "/ethi:ki": "\u12AA",
+ "/ethi:ko": "\u12AE",
+ "/ethi:koa": "\u12AF",
+ "/ethi:ku": "\u12A9",
+ "/ethi:kwa": "\u12B0",
+ "/ethi:kwaa": "\u12B3",
+ "/ethi:kwe": "\u12B5",
+ "/ethi:kwee": "\u12B4",
+ "/ethi:kwi": "\u12B2",
+ "/ethi:kxa": "\u12B8",
+ "/ethi:kxaa": "\u12BB",
+ "/ethi:kxe": "\u12BD",
+ "/ethi:kxee": "\u12BC",
+ "/ethi:kxi": "\u12BA",
+ "/ethi:kxo": "\u12BE",
+ "/ethi:kxu": "\u12B9",
+ "/ethi:kxwa": "\u12C0",
+ "/ethi:kxwaa": "\u12C3",
+ "/ethi:kxwe": "\u12C5",
+ "/ethi:kxwee": "\u12C4",
+ "/ethi:kxwi": "\u12C2",
+ "/ethi:la": "\u1208",
+ "/ethi:laa": "\u120B",
+ "/ethi:le": "\u120D",
+ "/ethi:lee": "\u120C",
+ "/ethi:li": "\u120A",
+ "/ethi:lo": "\u120E",
+ "/ethi:lu": "\u1209",
+ "/ethi:lwa": "\u120F",
+ "/ethi:ma": "\u1218",
+ "/ethi:maa": "\u121B",
+ "/ethi:me": "\u121D",
+ "/ethi:mee": "\u121C",
+ "/ethi:mi": "\u121A",
+ "/ethi:mo": "\u121E",
+ "/ethi:mu": "\u1219",
+ "/ethi:mwa": "\u121F",
+ "/ethi:mya": "\u1359",
+ "/ethi:na": "\u1290",
+ "/ethi:naa": "\u1293",
+ "/ethi:ne": "\u1295",
+ "/ethi:nee": "\u1294",
+ "/ethi:ni": "\u1292",
+ "/ethi:nine": "\u1371",
+ "/ethi:ninety": "\u137A",
+ "/ethi:no": "\u1296",
+ "/ethi:nu": "\u1291",
+ "/ethi:nwa": "\u1297",
+ "/ethi:nya": "\u1298",
+ "/ethi:nyaa": "\u129B",
+ "/ethi:nye": "\u129D",
+ "/ethi:nyee": "\u129C",
+ "/ethi:nyi": "\u129A",
+ "/ethi:nyo": "\u129E",
+ "/ethi:nyu": "\u1299",
+ "/ethi:nywa": "\u129F",
+ "/ethi:oglottal": "\u12A6",
+ "/ethi:one": "\u1369",
+ "/ethi:pa": "\u1350",
+ "/ethi:paa": "\u1353",
+ "/ethi:paragraphseparator": "\u1368",
+ "/ethi:pe": "\u1355",
+ "/ethi:pee": "\u1354",
+ "/ethi:pha": "\u1330",
+ "/ethi:phaa": "\u1333",
+ "/ethi:pharyngeala": "\u12D0",
+ "/ethi:pharyngealaa": "\u12D3",
+ "/ethi:pharyngeale": "\u12D5",
+ "/ethi:pharyngealee": "\u12D4",
+ "/ethi:pharyngeali": "\u12D2",
+ "/ethi:pharyngealo": "\u12D6",
+ "/ethi:pharyngealu": "\u12D1",
+ "/ethi:phe": "\u1335",
+ "/ethi:phee": "\u1334",
+ "/ethi:phi": "\u1332",
+ "/ethi:pho": "\u1336",
+ "/ethi:phu": "\u1331",
+ "/ethi:phwa": "\u1337",
+ "/ethi:pi": "\u1352",
+ "/ethi:po": "\u1356",
+ "/ethi:prefacecolon": "\u1366",
+ "/ethi:pu": "\u1351",
+ "/ethi:pwa": "\u1357",
+ "/ethi:qa": "\u1240",
+ "/ethi:qaa": "\u1243",
+ "/ethi:qe": "\u1245",
+ "/ethi:qee": "\u1244",
+ "/ethi:qha": "\u1250",
+ "/ethi:qhaa": "\u1253",
+ "/ethi:qhe": "\u1255",
+ "/ethi:qhee": "\u1254",
+ "/ethi:qhi": "\u1252",
+ "/ethi:qho": "\u1256",
+ "/ethi:qhu": "\u1251",
+ "/ethi:qhwa": "\u1258",
+ "/ethi:qhwaa": "\u125B",
+ "/ethi:qhwe": "\u125D",
+ "/ethi:qhwee": "\u125C",
+ "/ethi:qhwi": "\u125A",
+ "/ethi:qi": "\u1242",
+ "/ethi:qo": "\u1246",
+ "/ethi:qoa": "\u1247",
+ "/ethi:qu": "\u1241",
+ "/ethi:questionmark": "\u1367",
+ "/ethi:qwa": "\u1248",
+ "/ethi:qwaa": "\u124B",
+ "/ethi:qwe": "\u124D",
+ "/ethi:qwee": "\u124C",
+ "/ethi:qwi": "\u124A",
+ "/ethi:ra": "\u1228",
+ "/ethi:raa": "\u122B",
+ "/ethi:re": "\u122D",
+ "/ethi:ree": "\u122C",
+ "/ethi:ri": "\u122A",
+ "/ethi:ro": "\u122E",
+ "/ethi:ru": "\u1229",
+ "/ethi:rwa": "\u122F",
+ "/ethi:rya": "\u1358",
+ "/ethi:sa": "\u1230",
+ "/ethi:saa": "\u1233",
+ "/ethi:se": "\u1235",
+ "/ethi:sectionmark": "\u1360",
+ "/ethi:see": "\u1234",
+ "/ethi:semicolon": "\u1364",
+ "/ethi:seven": "\u136F",
+ "/ethi:seventy": "\u1378",
+ "/ethi:sha": "\u1238",
+ "/ethi:shaa": "\u123B",
+ "/ethi:she": "\u123D",
+ "/ethi:shee": "\u123C",
+ "/ethi:shi": "\u123A",
+ "/ethi:sho": "\u123E",
+ "/ethi:shu": "\u1239",
+ "/ethi:shwa": "\u123F",
+ "/ethi:si": "\u1232",
+ "/ethi:six": "\u136E",
+ "/ethi:sixty": "\u1377",
+ "/ethi:so": "\u1236",
+ "/ethi:su": "\u1231",
+ "/ethi:swa": "\u1237",
+ "/ethi:sza": "\u1220",
+ "/ethi:szaa": "\u1223",
+ "/ethi:sze": "\u1225",
+ "/ethi:szee": "\u1224",
+ "/ethi:szi": "\u1222",
+ "/ethi:szo": "\u1226",
+ "/ethi:szu": "\u1221",
+ "/ethi:szwa": "\u1227",
+ "/ethi:ta": "\u1270",
+ "/ethi:taa": "\u1273",
+ "/ethi:te": "\u1275",
+ "/ethi:tee": "\u1274",
+ "/ethi:ten": "\u1372",
+ "/ethi:tenthousand": "\u137C",
+ "/ethi:tha": "\u1320",
+ "/ethi:thaa": "\u1323",
+ "/ethi:the": "\u1325",
+ "/ethi:thee": "\u1324",
+ "/ethi:thi": "\u1322",
+ "/ethi:thirty": "\u1374",
+ "/ethi:tho": "\u1326",
+ "/ethi:three": "\u136B",
+ "/ethi:thu": "\u1321",
+ "/ethi:thwa": "\u1327",
+ "/ethi:ti": "\u1272",
+ "/ethi:to": "\u1276",
+ "/ethi:tsa": "\u1338",
+ "/ethi:tsaa": "\u133B",
+ "/ethi:tse": "\u133D",
+ "/ethi:tsee": "\u133C",
+ "/ethi:tsi": "\u133A",
+ "/ethi:tso": "\u133E",
+ "/ethi:tsu": "\u1339",
+ "/ethi:tswa": "\u133F",
+ "/ethi:tu": "\u1271",
+ "/ethi:twa": "\u1277",
+ "/ethi:twenty": "\u1373",
+ "/ethi:two": "\u136A",
+ "/ethi:tza": "\u1340",
+ "/ethi:tzaa": "\u1343",
+ "/ethi:tze": "\u1345",
+ "/ethi:tzee": "\u1344",
+ "/ethi:tzi": "\u1342",
+ "/ethi:tzo": "\u1346",
+ "/ethi:tzoa": "\u1347",
+ "/ethi:tzu": "\u1341",
+ "/ethi:uglottal": "\u12A1",
+ "/ethi:va": "\u1268",
+ "/ethi:vaa": "\u126B",
+ "/ethi:ve": "\u126D",
+ "/ethi:vee": "\u126C",
+ "/ethi:vi": "\u126A",
+ "/ethi:vo": "\u126E",
+ "/ethi:vowellengthmarkcmb": "\u135E",
+ "/ethi:vu": "\u1269",
+ "/ethi:vwa": "\u126F",
+ "/ethi:wa": "\u12C8",
+ "/ethi:waa": "\u12CB",
+ "/ethi:waglottal": "\u12A7",
+ "/ethi:we": "\u12CD",
+ "/ethi:wee": "\u12CC",
+ "/ethi:wi": "\u12CA",
+ "/ethi:wo": "\u12CE",
+ "/ethi:woa": "\u12CF",
+ "/ethi:wordspace": "\u1361",
+ "/ethi:wu": "\u12C9",
+ "/ethi:xa": "\u1280",
+ "/ethi:xaa": "\u1283",
+ "/ethi:xe": "\u1285",
+ "/ethi:xee": "\u1284",
+ "/ethi:xi": "\u1282",
+ "/ethi:xo": "\u1286",
+ "/ethi:xoa": "\u1287",
+ "/ethi:xu": "\u1281",
+ "/ethi:xwa": "\u1288",
+ "/ethi:xwaa": "\u128B",
+ "/ethi:xwe": "\u128D",
+ "/ethi:xwee": "\u128C",
+ "/ethi:xwi": "\u128A",
+ "/ethi:ya": "\u12E8",
+ "/ethi:yaa": "\u12EB",
+ "/ethi:ye": "\u12ED",
+ "/ethi:yee": "\u12EC",
+ "/ethi:yi": "\u12EA",
+ "/ethi:yo": "\u12EE",
+ "/ethi:yoa": "\u12EF",
+ "/ethi:yu": "\u12E9",
+ "/ethi:za": "\u12D8",
+ "/ethi:zaa": "\u12DB",
+ "/ethi:ze": "\u12DD",
+ "/ethi:zee": "\u12DC",
+ "/ethi:zha": "\u12E0",
+ "/ethi:zhaa": "\u12E3",
+ "/ethi:zhe": "\u12E5",
+ "/ethi:zhee": "\u12E4",
+ "/ethi:zhi": "\u12E2",
+ "/ethi:zho": "\u12E6",
+ "/ethi:zhu": "\u12E1",
+ "/ethi:zhwa": "\u12E7",
+ "/ethi:zi": "\u12DA",
+ "/ethi:zo": "\u12DE",
+ "/ethi:zu": "\u12D9",
+ "/ethi:zwa": "\u12DF",
+ "/etilde": "\u1EBD",
+ "/etildebelow": "\u1E1B",
+ "/etnahta:hb": "\u0591",
+ "/etnahtafoukhhebrew": "\u0591",
+ "/etnahtafoukhlefthebrew": "\u0591",
+ "/etnahtahebrew": "\u0591",
+ "/etnahtalefthebrew": "\u0591",
+ "/eturned": "\u01DD",
+ "/eukorean": "\u3161",
+ "/eukrcyr": "\u0454",
+ "/euler": "\u2107",
+ "/euro": "\u20AC",
+ "/euroarchaic": "\u20A0",
+ "/europeanCastle": "\u1F3F0",
+ "/europeanPostOffice": "\u1F3E4",
+ "/evergreenTree": "\u1F332",
+ "/evowelsignbengali": "\u09C7",
+ "/evowelsigndeva": "\u0947",
+ "/evowelsigngujarati": "\u0AC7",
+ "/excellentideographiccircled": "\u329D",
+ "/excess": "\u2239",
+ "/exclam": "\u0021",
+ "/exclamarmenian": "\u055C",
+ "/exclamationquestion": "\u2049",
+ "/exclamdbl": "\u203C",
+ "/exclamdown": "\u00A1",
+ "/exclamdownsmall": "\uF7A1",
+ "/exclammonospace": "\uFF01",
+ "/exclamsmall": "\uF721",
+ "/existential": "\u2203",
+ "/expressionlessFace": "\u1F611",
+ "/extraterrestrialAlien": "\u1F47D",
+ "/eye": "\u1F441",
+ "/eyeglasses": "\u1F453",
+ "/eyes": "\u1F440",
+ "/ezh": "\u0292",
+ "/ezhcaron": "\u01EF",
+ "/ezhcurl": "\u0293",
+ "/ezhreversed": "\u01B9",
+ "/ezhtail": "\u01BA",
+ "/f": "\u0066",
+ "/f_f": "\uFB00",
+ "/f_f_i": "\uFB03",
+ "/f_f_l": "\uFB04",
+ "/faceMassage": "\u1F486",
+ "/faceSavouringDeliciousFood": "\u1F60B",
+ "/faceScreamingInFear": "\u1F631",
+ "/faceThrowingAKiss": "\u1F618",
+ "/faceWithColdSweat": "\u1F613",
+ "/faceWithLookOfTriumph": "\u1F624",
+ "/faceWithMedicalMask": "\u1F637",
+ "/faceWithNoGoodGesture": "\u1F645",
+ "/faceWithOkGesture": "\u1F646",
+ "/faceWithOpenMouth": "\u1F62E",
+ "/faceWithOpenMouthAndColdSweat": "\u1F630",
+ "/faceWithRollingEyes": "\u1F644",
+ "/faceWithStuckOutTongue": "\u1F61B",
+ "/faceWithStuckOutTongueAndTightlyClosedEyes": "\u1F61D",
+ "/faceWithStuckOutTongueAndWinkingEye": "\u1F61C",
+ "/faceWithTearsOfJoy": "\u1F602",
+ "/faceWithoutMouth": "\u1F636",
+ "/facsimile": "\u213B",
+ "/factory": "\u1F3ED",
+ "/fadeva": "\u095E",
+ "/fagurmukhi": "\u0A5E",
+ "/fahrenheit": "\u2109",
+ "/fallenLeaf": "\u1F342",
+ "/fallingdiagonal": "\u27CD",
+ "/fallingdiagonalincircleinsquareblackwhite": "\u26DE",
+ "/family": "\u1F46A",
+ "/farsi": "\u262B",
+ "/farsiYehDigitFourBelow": "\u0777",
+ "/farsiYehDigitThreeAbove": "\u0776",
+ "/farsiYehDigitTwoAbove": "\u0775",
+ "/fatha": "\u064E",
+ "/fathaIsol": "\uFE76",
+ "/fathaMedi": "\uFE77",
+ "/fathaarabic": "\u064E",
+ "/fathalowarabic": "\u064E",
+ "/fathasmall": "\u0618",
+ "/fathatan": "\u064B",
+ "/fathatanIsol": "\uFE70",
+ "/fathatanarabic": "\u064B",
+ "/fathatwodotsdots": "\u065E",
+ "/fatherChristmas": "\u1F385",
+ "/faxIcon": "\u1F5B7",
+ "/faxMachine": "\u1F4E0",
+ "/fbopomofo": "\u3108",
+ "/fcircle": "\u24D5",
+ "/fdot": "\u1E1F",
+ "/fdotaccent": "\u1E1F",
+ "/fearfulFace": "\u1F628",
+ "/februarytelegraph": "\u32C1",
+ "/feh.fina": "\uFED2",
+ "/feh.init": "\uFED3",
+ "/feh.init_alefmaksura.fina": "\uFC31",
+ "/feh.init_hah.fina": "\uFC2E",
+ "/feh.init_hah.medi": "\uFCBF",
+ "/feh.init_jeem.fina": "\uFC2D",
+ "/feh.init_jeem.medi": "\uFCBE",
+ "/feh.init_khah.fina": "\uFC2F",
+ "/feh.init_khah.medi": "\uFCC0",
+ "/feh.init_khah.medi_meem.medi": "\uFD7D",
+ "/feh.init_meem.fina": "\uFC30",
+ "/feh.init_meem.medi": "\uFCC1",
+ "/feh.init_yeh.fina": "\uFC32",
+ "/feh.isol": "\uFED1",
+ "/feh.medi": "\uFED4",
+ "/feh.medi_alefmaksura.fina": "\uFC7C",
+ "/feh.medi_khah.medi_meem.fina": "\uFD7C",
+ "/feh.medi_meem.medi_yeh.fina": "\uFDC1",
+ "/feh.medi_yeh.fina": "\uFC7D",
+ "/fehThreeDotsUpBelow": "\u0761",
+ "/fehTwoDotsBelow": "\u0760",
+ "/feharabic": "\u0641",
+ "/feharmenian": "\u0586",
+ "/fehdotbelow": "\u06A3",
+ "/fehdotbelowright": "\u06A2",
+ "/fehfinalarabic": "\uFED2",
+ "/fehinitialarabic": "\uFED3",
+ "/fehmedialarabic": "\uFED4",
+ "/fehthreedotsbelow": "\u06A5",
+ "/feicoptic": "\u03E5",
+ "/female": "\u2640",
+ "/femaleideographiccircled": "\u329B",
+ "/feng": "\u02A9",
+ "/ferrisWheel": "\u1F3A1",
+ "/ferry": "\u26F4",
+ "/festivalideographicparen": "\u3240",
+ "/ff": "\uFB00",
+ "/ffi": "\uFB03",
+ "/ffl": "\uFB04",
+ "/fhook": "\u0192",
+ "/fi": "\uFB01", # ligature "fi"
+ "/fieldHockeyStickAndBall": "\u1F3D1",
+ "/fifteencircle": "\u246E",
+ "/fifteencircleblack": "\u24EF",
+ "/fifteenparen": "\u2482",
+ "/fifteenparenthesized": "\u2482",
+ "/fifteenperiod": "\u2496",
+ "/fifty.roman": "\u216C",
+ "/fifty.romansmall": "\u217C",
+ "/fiftycircle": "\u32BF",
+ "/fiftycirclesquare": "\u324C",
+ "/fiftyearlyform.roman": "\u2186",
+ "/fiftythousand.roman": "\u2187",
+ "/figuredash": "\u2012",
+ "/figurespace": "\u2007",
+ "/fileCabinet": "\u1F5C4",
+ "/fileFolder": "\u1F4C1",
+ "/filledbox": "\u25A0",
+ "/filledrect": "\u25AC",
+ "/filledstopabove": "\u06EC",
+ "/filmFrames": "\u1F39E",
+ "/filmProjector": "\u1F4FD",
+ "/finalkaf": "\u05DA",
+ "/finalkaf:hb": "\u05DA",
+ "/finalkafdagesh": "\uFB3A",
+ "/finalkafdageshhebrew": "\uFB3A",
+ "/finalkafhebrew": "\u05DA",
+ "/finalkafqamats": "\u05DA",
+ "/finalkafqamatshebrew": "\u05DA",
+ "/finalkafsheva": "\u05DA",
+ "/finalkafshevahebrew": "\u05DA",
+ "/finalkafwithdagesh:hb": "\uFB3A",
+ "/finalmem": "\u05DD",
+ "/finalmem:hb": "\u05DD",
+ "/finalmemhebrew": "\u05DD",
+ "/finalmemwide:hb": "\uFB26",
+ "/finalnun": "\u05DF",
+ "/finalnun:hb": "\u05DF",
+ "/finalnunhebrew": "\u05DF",
+ "/finalpe": "\u05E3",
+ "/finalpe:hb": "\u05E3",
+ "/finalpehebrew": "\u05E3",
+ "/finalpewithdagesh:hb": "\uFB43",
+ "/finalsigma": "\u03C2",
+ "/finaltsadi": "\u05E5",
+ "/finaltsadi:hb": "\u05E5",
+ "/finaltsadihebrew": "\u05E5",
+ "/financialideographiccircled": "\u3296",
+ "/financialideographicparen": "\u3236",
+ "/finsular": "\uA77C",
+ "/fire": "\u1F525",
+ "/fireEngine": "\u1F692",
+ "/fireideographiccircled": "\u328B",
+ "/fireideographicparen": "\u322B",
+ "/fireworkSparkler": "\u1F387",
+ "/fireworks": "\u1F386",
+ "/firstQuarterMoon": "\u1F313",
+ "/firstQuarterMoonFace": "\u1F31B",
+ "/firstquartermoon": "\u263D",
+ "/firststrongisolate": "\u2068",
+ "/firsttonechinese": "\u02C9",
+ "/fish": "\u1F41F",
+ "/fishCakeSwirlDesign": "\u1F365",
+ "/fisheye": "\u25C9",
+ "/fishingPoleAndFish": "\u1F3A3",
+ "/fistedHandSign": "\u1F44A",
+ "/fitacyr": "\u0473",
+ "/fitacyrillic": "\u0473",
+ "/five": "\u0035",
+ "/five.inferior": "\u2085",
+ "/five.roman": "\u2164",
+ "/five.romansmall": "\u2174",
+ "/five.superior": "\u2075",
+ "/fivearabic": "\u0665",
+ "/fivebengali": "\u09EB",
+ "/fivecircle": "\u2464",
+ "/fivecircledbl": "\u24F9",
+ "/fivecircleinversesansserif": "\u278E",
+ "/fivecomma": "\u1F106",
+ "/fivedeva": "\u096B",
+ "/fivedot": "\u2E2D",
+ "/fivedotpunctuation": "\u2059",
+ "/fiveeighths": "\u215D",
+ "/fivefar": "\u06F5",
+ "/fivegujarati": "\u0AEB",
+ "/fivegurmukhi": "\u0A6B",
+ "/fivehackarabic": "\u0665",
+ "/fivehangzhou": "\u3025",
+ "/fivehundred.roman": "\u216E",
+ "/fivehundred.romansmall": "\u217E",
+ "/fiveideographiccircled": "\u3284",
+ "/fiveideographicparen": "\u3224",
+ "/fiveinferior": "\u2085",
+ "/fivemonospace": "\uFF15",
+ "/fiveoldstyle": "\uF735",
+ "/fiveparen": "\u2478",
+ "/fiveparenthesized": "\u2478",
+ "/fiveperiod": "\u248C",
+ "/fivepersian": "\u06F5",
+ "/fivepointedstar": "\u066D",
+ "/fivepointonesquare": "\u1F1A0",
+ "/fiveroman": "\u2174",
+ "/fivesixths": "\u215A",
+ "/fivesuperior": "\u2075",
+ "/fivethai": "\u0E55",
+ "/fivethousand.roman": "\u2181",
+ "/fl": "\uFB02",
+ "/flagblack": "\u2691",
+ "/flaghorizontalmiddlestripeblackwhite": "\u26FF",
+ "/flaginhole": "\u26F3",
+ "/flagwhite": "\u2690",
+ "/flatness": "\u23E5",
+ "/fleurdelis": "\u269C",
+ "/flexedBiceps": "\u1F4AA",
+ "/floorleft": "\u230A",
+ "/floorright": "\u230B",
+ "/floppyDisk": "\u1F4BE",
+ "/floralheartbulletreversedrotated": "\u2619",
+ "/florin": "\u0192",
+ "/flower": "\u2698",
+ "/flowerPlayingCards": "\u1F3B4",
+ "/flowerpunctuationmark": "\u2055",
+ "/flushedFace": "\u1F633",
+ "/flyingEnvelope": "\u1F585",
+ "/flyingSaucer": "\u1F6F8",
+ "/fmfullwidth": "\u3399",
+ "/fmonospace": "\uFF46",
+ "/fmsquare": "\u3399",
+ "/fofanthai": "\u0E1F",
+ "/fofathai": "\u0E1D",
+ "/fog": "\u1F32B",
+ "/foggy": "\u1F301",
+ "/folder": "\u1F5C0",
+ "/fongmanthai": "\u0E4F",
+ "/footnote": "\u0602",
+ "/footprints": "\u1F463",
+ "/footsquare": "\u23CD",
+ "/forall": "\u2200",
+ "/forces": "\u22A9",
+ "/fork": "\u2442",
+ "/forkKnife": "\u1F374",
+ "/forkKnifePlate": "\u1F37D",
+ "/forsamaritan": "\u214F",
+ "/fortycircle": "\u32B5",
+ "/fortycirclesquare": "\u324B",
+ "/fortyeightcircle": "\u32BD",
+ "/fortyfivecircle": "\u32BA",
+ "/fortyfourcircle": "\u32B9",
+ "/fortyninecircle": "\u32BE",
+ "/fortyonecircle": "\u32B6",
+ "/fortysevencircle": "\u32BC",
+ "/fortysixcircle": "\u32BB",
+ "/fortythreecircle": "\u32B8",
+ "/fortytwocircle": "\u32B7",
+ "/fountain": "\u26F2",
+ "/four": "\u0034",
+ "/four.inferior": "\u2084",
+ "/four.roman": "\u2163",
+ "/four.romansmall": "\u2173",
+ "/four.superior": "\u2074",
+ "/fourLeafClover": "\u1F340",
+ "/fourarabic": "\u0664",
+ "/fourbengali": "\u09EA",
+ "/fourcircle": "\u2463",
+ "/fourcircledbl": "\u24F8",
+ "/fourcircleinversesansserif": "\u278D",
+ "/fourcomma": "\u1F105",
+ "/fourdeva": "\u096A",
+ "/fourdotmark": "\u205B",
+ "/fourdotpunctuation": "\u2058",
+ "/fourfar": "\u06F4",
+ "/fourfifths": "\u2158",
+ "/fourgujarati": "\u0AEA",
+ "/fourgurmukhi": "\u0A6A",
+ "/fourhackarabic": "\u0664",
+ "/fourhangzhou": "\u3024",
+ "/fourideographiccircled": "\u3283",
+ "/fourideographicparen": "\u3223",
+ "/fourinferior": "\u2084",
+ "/fourksquare": "\u1F19E",
+ "/fourmonospace": "\uFF14",
+ "/fournumeratorbengali": "\u09F7",
+ "/fouroldstyle": "\uF734",
+ "/fourparen": "\u2477",
+ "/fourparenthesized": "\u2477",
+ "/fourperemspace": "\u2005",
+ "/fourperiod": "\u248B",
+ "/fourpersian": "\u06F4",
+ "/fourroman": "\u2173",
+ "/foursuperior": "\u2074",
+ "/fourteencircle": "\u246D",
+ "/fourteencircleblack": "\u24EE",
+ "/fourteenparen": "\u2481",
+ "/fourteenparenthesized": "\u2481",
+ "/fourteenperiod": "\u2495",
+ "/fourthai": "\u0E54",
+ "/fourthtonechinese": "\u02CB",
+ "/fparen": "\u24A1",
+ "/fparenthesized": "\u24A1",
+ "/fraction": "\u2044",
+ "/frameAnX": "\u1F5BE",
+ "/framePicture": "\u1F5BC",
+ "/frameTiles": "\u1F5BD",
+ "/franc": "\u20A3",
+ "/freesquare": "\u1F193",
+ "/frenchFries": "\u1F35F",
+ "/freversedepigraphic": "\uA7FB",
+ "/friedShrimp": "\u1F364",
+ "/frogFace": "\u1F438",
+ "/front-facingBabyChick": "\u1F425",
+ "/frown": "\u2322",
+ "/frowningFaceWithOpenMouth": "\u1F626",
+ "/frowningfacewhite": "\u2639",
+ "/fstroke": "\uA799",
+ "/fturned": "\u214E",
+ "/fuelpump": "\u26FD",
+ "/fullBlock": "\u2588",
+ "/fullMoon": "\u1F315",
+ "/fullMoonFace": "\u1F31D",
+ "/functionapplication": "\u2061",
+ "/funeralurn": "\u26B1",
+ "/fuse": "\u23DB",
+ "/fwd:A": "\uFF21",
+ "/fwd:B": "\uFF22",
+ "/fwd:C": "\uFF23",
+ "/fwd:D": "\uFF24",
+ "/fwd:E": "\uFF25",
+ "/fwd:F": "\uFF26",
+ "/fwd:G": "\uFF27",
+ "/fwd:H": "\uFF28",
+ "/fwd:I": "\uFF29",
+ "/fwd:J": "\uFF2A",
+ "/fwd:K": "\uFF2B",
+ "/fwd:L": "\uFF2C",
+ "/fwd:M": "\uFF2D",
+ "/fwd:N": "\uFF2E",
+ "/fwd:O": "\uFF2F",
+ "/fwd:P": "\uFF30",
+ "/fwd:Q": "\uFF31",
+ "/fwd:R": "\uFF32",
+ "/fwd:S": "\uFF33",
+ "/fwd:T": "\uFF34",
+ "/fwd:U": "\uFF35",
+ "/fwd:V": "\uFF36",
+ "/fwd:W": "\uFF37",
+ "/fwd:X": "\uFF38",
+ "/fwd:Y": "\uFF39",
+ "/fwd:Z": "\uFF3A",
+ "/fwd:a": "\uFF41",
+ "/fwd:ampersand": "\uFF06",
+ "/fwd:asciicircum": "\uFF3E",
+ "/fwd:asciitilde": "\uFF5E",
+ "/fwd:asterisk": "\uFF0A",
+ "/fwd:at": "\uFF20",
+ "/fwd:b": "\uFF42",
+ "/fwd:backslash": "\uFF3C",
+ "/fwd:bar": "\uFF5C",
+ "/fwd:braceleft": "\uFF5B",
+ "/fwd:braceright": "\uFF5D",
+ "/fwd:bracketleft": "\uFF3B",
+ "/fwd:bracketright": "\uFF3D",
+ "/fwd:brokenbar": "\uFFE4",
+ "/fwd:c": "\uFF43",
+ "/fwd:centsign": "\uFFE0",
+ "/fwd:colon": "\uFF1A",
+ "/fwd:comma": "\uFF0C",
+ "/fwd:d": "\uFF44",
+ "/fwd:dollar": "\uFF04",
+ "/fwd:e": "\uFF45",
+ "/fwd:eight": "\uFF18",
+ "/fwd:equal": "\uFF1D",
+ "/fwd:exclam": "\uFF01",
+ "/fwd:f": "\uFF46",
+ "/fwd:five": "\uFF15",
+ "/fwd:four": "\uFF14",
+ "/fwd:g": "\uFF47",
+ "/fwd:grave": "\uFF40",
+ "/fwd:greater": "\uFF1E",
+ "/fwd:h": "\uFF48",
+ "/fwd:hyphen": "\uFF0D",
+ "/fwd:i": "\uFF49",
+ "/fwd:j": "\uFF4A",
+ "/fwd:k": "\uFF4B",
+ "/fwd:l": "\uFF4C",
+ "/fwd:leftwhiteparenthesis": "\uFF5F",
+ "/fwd:less": "\uFF1C",
+ "/fwd:m": "\uFF4D",
+ "/fwd:macron": "\uFFE3",
+ "/fwd:n": "\uFF4E",
+ "/fwd:nine": "\uFF19",
+ "/fwd:notsign": "\uFFE2",
+ "/fwd:numbersign": "\uFF03",
+ "/fwd:o": "\uFF4F",
+ "/fwd:one": "\uFF11",
+ "/fwd:p": "\uFF50",
+ "/fwd:parenthesisleft": "\uFF08",
+ "/fwd:parenthesisright": "\uFF09",
+ "/fwd:percent": "\uFF05",
+ "/fwd:period": "\uFF0E",
+ "/fwd:plus": "\uFF0B",
+ "/fwd:poundsign": "\uFFE1",
+ "/fwd:q": "\uFF51",
+ "/fwd:question": "\uFF1F",
+ "/fwd:quotedbl": "\uFF02",
+ "/fwd:quotesingle": "\uFF07",
+ "/fwd:r": "\uFF52",
+ "/fwd:rightwhiteparenthesis": "\uFF60",
+ "/fwd:s": "\uFF53",
+ "/fwd:semicolon": "\uFF1B",
+ "/fwd:seven": "\uFF17",
+ "/fwd:six": "\uFF16",
+ "/fwd:slash": "\uFF0F",
+ "/fwd:t": "\uFF54",
+ "/fwd:three": "\uFF13",
+ "/fwd:two": "\uFF12",
+ "/fwd:u": "\uFF55",
+ "/fwd:underscore": "\uFF3F",
+ "/fwd:v": "\uFF56",
+ "/fwd:w": "\uFF57",
+ "/fwd:wonsign": "\uFFE6",
+ "/fwd:x": "\uFF58",
+ "/fwd:y": "\uFF59",
+ "/fwd:yensign": "\uFFE5",
+ "/fwd:z": "\uFF5A",
+ "/fwd:zero": "\uFF10",
+ "/g": "\u0067",
+ "/gabengali": "\u0997",
+ "/gacute": "\u01F5",
+ "/gadeva": "\u0917",
+ "/gaf": "\u06AF",
+ "/gaf.fina": "\uFB93",
+ "/gaf.init": "\uFB94",
+ "/gaf.isol": "\uFB92",
+ "/gaf.medi": "\uFB95",
+ "/gafarabic": "\u06AF",
+ "/gaffinalarabic": "\uFB93",
+ "/gafinitialarabic": "\uFB94",
+ "/gafmedialarabic": "\uFB95",
+ "/gafring": "\u06B0",
+ "/gafthreedotsabove": "\u06B4",
+ "/gaftwodotsbelow": "\u06B2",
+ "/gagujarati": "\u0A97",
+ "/gagurmukhi": "\u0A17",
+ "/gahiragana": "\u304C",
+ "/gakatakana": "\u30AC",
+ "/galsquare": "\u33FF",
+ "/gameDie": "\u1F3B2",
+ "/gamma": "\u03B3",
+ "/gammadblstruck": "\u213D",
+ "/gammalatinsmall": "\u0263",
+ "/gammasuperior": "\u02E0",
+ "/gammasupmod": "\u02E0",
+ "/gamurda": "\uA993",
+ "/gangiacoptic": "\u03EB",
+ "/ganmasquare": "\u330F",
+ "/garonsquare": "\u330E",
+ "/gbfullwidth": "\u3387",
+ "/gbopomofo": "\u310D",
+ "/gbreve": "\u011F",
+ "/gcaron": "\u01E7",
+ "/gcedilla": "\u0123",
+ "/gcircle": "\u24D6",
+ "/gcircumflex": "\u011D",
+ "/gcommaaccent": "\u0123",
+ "/gdot": "\u0121",
+ "/gdotaccent": "\u0121",
+ "/gear": "\u2699",
+ "/gearhles": "\u26EE",
+ "/gearouthub": "\u26ED",
+ "/gecyr": "\u0433",
+ "/gecyrillic": "\u0433",
+ "/gehiragana": "\u3052",
+ "/gehookcyr": "\u0495",
+ "/gehookstrokecyr": "\u04FB",
+ "/gekatakana": "\u30B2",
+ "/gemStone": "\u1F48E",
+ "/gemini": "\u264A",
+ "/geometricallyequal": "\u2251",
+ "/geometricallyequivalent": "\u224E",
+ "/geometricproportion": "\u223A",
+ "/geresh:hb": "\u05F3",
+ "/gereshMuqdam:hb": "\u059D",
+ "/gereshaccenthebrew": "\u059C",
+ "/gereshhebrew": "\u05F3",
+ "/gereshmuqdamhebrew": "\u059D",
+ "/germandbls": "\u00DF",
+ "/germanpenny": "\u20B0",
+ "/gershayim:hb": "\u05F4",
+ "/gershayimaccenthebrew": "\u059E",
+ "/gershayimhebrew": "\u05F4",
+ "/gestrokecyr": "\u0493",
+ "/getailcyr": "\u04F7",
+ "/getamark": "\u3013",
+ "/geupcyr": "\u0491",
+ "/ghabengali": "\u0998",
+ "/ghadarmenian": "\u0572",
+ "/ghadeva": "\u0918",
+ "/ghagujarati": "\u0A98",
+ "/ghagurmukhi": "\u0A18",
+ "/ghain": "\u063A",
+ "/ghain.fina": "\uFECE",
+ "/ghain.init": "\uFECF",
+ "/ghain.init_alefmaksura.fina": "\uFCF9",
+ "/ghain.init_jeem.fina": "\uFC2B",
+ "/ghain.init_jeem.medi": "\uFCBC",
+ "/ghain.init_meem.fina": "\uFC2C",
+ "/ghain.init_meem.medi": "\uFCBD",
+ "/ghain.init_yeh.fina": "\uFCFA",
+ "/ghain.isol": "\uFECD",
+ "/ghain.medi": "\uFED0",
+ "/ghain.medi_alefmaksura.fina": "\uFD15",
+ "/ghain.medi_meem.medi_alefmaksura.fina": "\uFD7B",
+ "/ghain.medi_meem.medi_meem.fina": "\uFD79",
+ "/ghain.medi_meem.medi_yeh.fina": "\uFD7A",
+ "/ghain.medi_yeh.fina": "\uFD16",
+ "/ghainarabic": "\u063A",
+ "/ghaindotbelow": "\u06FC",
+ "/ghainfinalarabic": "\uFECE",
+ "/ghaininitialarabic": "\uFECF",
+ "/ghainmedialarabic": "\uFED0",
+ "/ghemiddlehookcyrillic": "\u0495",
+ "/ghestrokecyrillic": "\u0493",
+ "/gheupturncyrillic": "\u0491",
+ "/ghhadeva": "\u095A",
+ "/ghhagurmukhi": "\u0A5A",
+ "/ghook": "\u0260",
+ "/ghost": "\u1F47B",
+ "/ghzfullwidth": "\u3393",
+ "/ghzsquare": "\u3393",
+ "/gigasquare": "\u3310",
+ "/gihiragana": "\u304E",
+ "/gikatakana": "\u30AE",
+ "/gimarmenian": "\u0563",
+ "/gimel": "\u05D2",
+ "/gimel:hb": "\u05D2",
+ "/gimeldagesh": "\uFB32",
+ "/gimeldageshhebrew": "\uFB32",
+ "/gimelhebrew": "\u05D2",
+ "/gimelwithdagesh:hb": "\uFB32",
+ "/giniisquare": "\u3311",
+ "/ginsularturned": "\uA77F",
+ "/girl": "\u1F467",
+ "/girls": "\u1F6CA",
+ "/girudaasquare": "\u3313",
+ "/gjecyr": "\u0453",
+ "/gjecyrillic": "\u0453",
+ "/globeMeridians": "\u1F310",
+ "/glottalinvertedstroke": "\u01BE",
+ "/glottalstop": "\u0294",
+ "/glottalstopinverted": "\u0296",
+ "/glottalstopmod": "\u02C0",
+ "/glottalstopreversed": "\u0295",
+ "/glottalstopreversedmod": "\u02C1",
+ "/glottalstopreversedsuperior": "\u02E4",
+ "/glottalstopstroke": "\u02A1",
+ "/glottalstopstrokereversed": "\u02A2",
+ "/glottalstopsupreversedmod": "\u02E4",
+ "/glowingStar": "\u1F31F",
+ "/gmacron": "\u1E21",
+ "/gmonospace": "\uFF47",
+ "/gmtr:diamondblack": "\u25C6",
+ "/gmtr:diamondwhite": "\u25C7",
+ "/gnrl:hyphen": "\u2010",
+ "/goat": "\u1F410",
+ "/gobliquestroke": "\uA7A1",
+ "/gohiragana": "\u3054",
+ "/gokatakana": "\u30B4",
+ "/golfer": "\u1F3CC",
+ "/gpafullwidth": "\u33AC",
+ "/gparen": "\u24A2",
+ "/gparenthesized": "\u24A2",
+ "/gpasquare": "\u33AC",
+ "/gr:acute": "\u1FFD",
+ "/gr:grave": "\u1FEF",
+ "/gr:question": "\u037E",
+ "/gr:tilde": "\u1FC0",
+ "/gradient": "\u2207",
+ "/graduationCap": "\u1F393",
+ "/grapes": "\u1F347",
+ "/grave": "\u0060",
+ "/gravebelowcmb": "\u0316",
+ "/gravecmb": "\u0300",
+ "/gravecomb": "\u0300",
+ "/gravedblmiddlemod": "\u02F5",
+ "/gravedeva": "\u0953",
+ "/gravelowmod": "\u02CE",
+ "/gravemiddlemod": "\u02F4",
+ "/gravemod": "\u02CB",
+ "/gravemonospace": "\uFF40",
+ "/gravetonecmb": "\u0340",
+ "/greater": "\u003E",
+ "/greaterbutnotequal": "\u2269",
+ "/greaterbutnotequivalent": "\u22E7",
+ "/greaterdot": "\u22D7",
+ "/greaterequal": "\u2265",
+ "/greaterequalorless": "\u22DB",
+ "/greatermonospace": "\uFF1E",
+ "/greaterorequivalent": "\u2273",
+ "/greaterorless": "\u2277",
+ "/greateroverequal": "\u2267",
+ "/greatersmall": "\uFE65",
+ "/greenApple": "\u1F34F",
+ "/greenBook": "\u1F4D7",
+ "/greenHeart": "\u1F49A",
+ "/grimacingFace": "\u1F62C",
+ "/grinningCatFaceWithSmilingEyes": "\u1F638",
+ "/grinningFace": "\u1F600",
+ "/grinningFaceWithSmilingEyes": "\u1F601",
+ "/growingHeart": "\u1F497",
+ "/gscript": "\u0261",
+ "/gstroke": "\u01E5",
+ "/guarani": "\u20B2",
+ "/guardsman": "\u1F482",
+ "/gueh": "\u06B3",
+ "/gueh.fina": "\uFB97",
+ "/gueh.init": "\uFB98",
+ "/gueh.isol": "\uFB96",
+ "/gueh.medi": "\uFB99",
+ "/guhiragana": "\u3050",
+ "/guillemetleft": "\u00AB",
+ "/guillemetright": "\u00BB",
+ "/guillemotleft": "\u00AB",
+ "/guillemotright": "\u00BB",
+ "/guilsinglleft": "\u2039",
+ "/guilsinglright": "\u203A",
+ "/guitar": "\u1F3B8",
+ "/gujr:a": "\u0A85",
+ "/gujr:aa": "\u0A86",
+ "/gujr:aasign": "\u0ABE",
+ "/gujr:abbreviation": "\u0AF0",
+ "/gujr:ai": "\u0A90",
+ "/gujr:aisign": "\u0AC8",
+ "/gujr:anusvara": "\u0A82",
+ "/gujr:au": "\u0A94",
+ "/gujr:ausign": "\u0ACC",
+ "/gujr:avagraha": "\u0ABD",
+ "/gujr:ba": "\u0AAC",
+ "/gujr:bha": "\u0AAD",
+ "/gujr:binducandra": "\u0A81",
+ "/gujr:ca": "\u0A9A",
+ "/gujr:cha": "\u0A9B",
+ "/gujr:circlenuktaabove": "\u0AFE",
+ "/gujr:da": "\u0AA6",
+ "/gujr:dda": "\u0AA1",
+ "/gujr:ddha": "\u0AA2",
+ "/gujr:dha": "\u0AA7",
+ "/gujr:e": "\u0A8F",
+ "/gujr:ecandra": "\u0A8D",
+ "/gujr:eight": "\u0AEE",
+ "/gujr:esign": "\u0AC7",
+ "/gujr:esigncandra": "\u0AC5",
+ "/gujr:five": "\u0AEB",
+ "/gujr:four": "\u0AEA",
+ "/gujr:ga": "\u0A97",
+ "/gujr:gha": "\u0A98",
+ "/gujr:ha": "\u0AB9",
+ "/gujr:i": "\u0A87",
+ "/gujr:ii": "\u0A88",
+ "/gujr:iisign": "\u0AC0",
+ "/gujr:isign": "\u0ABF",
+ "/gujr:ja": "\u0A9C",
+ "/gujr:jha": "\u0A9D",
+ "/gujr:ka": "\u0A95",
+ "/gujr:kha": "\u0A96",
+ "/gujr:la": "\u0AB2",
+ "/gujr:lla": "\u0AB3",
+ "/gujr:llvocal": "\u0AE1",
+ "/gujr:llvocalsign": "\u0AE3",
+ "/gujr:lvocal": "\u0A8C",
+ "/gujr:lvocalsign": "\u0AE2",
+ "/gujr:ma": "\u0AAE",
+ "/gujr:maddah": "\u0AFC",
+ "/gujr:na": "\u0AA8",
+ "/gujr:nga": "\u0A99",
+ "/gujr:nine": "\u0AEF",
+ "/gujr:nna": "\u0AA3",
+ "/gujr:nukta": "\u0ABC",
+ "/gujr:nya": "\u0A9E",
+ "/gujr:o": "\u0A93",
+ "/gujr:ocandra": "\u0A91",
+ "/gujr:om": "\u0AD0",
+ "/gujr:one": "\u0AE7",
+ "/gujr:osign": "\u0ACB",
+ "/gujr:osigncandra": "\u0AC9",
+ "/gujr:pa": "\u0AAA",
+ "/gujr:pha": "\u0AAB",
+ "/gujr:ra": "\u0AB0",
+ "/gujr:rrvocal": "\u0AE0",
+ "/gujr:rrvocalsign": "\u0AC4",
+ "/gujr:rupee": "\u0AF1",
+ "/gujr:rvocal": "\u0A8B",
+ "/gujr:rvocalsign": "\u0AC3",
+ "/gujr:sa": "\u0AB8",
+ "/gujr:seven": "\u0AED",
+ "/gujr:sha": "\u0AB6",
+ "/gujr:shadda": "\u0AFB",
+ "/gujr:six": "\u0AEC",
+ "/gujr:ssa": "\u0AB7",
+ "/gujr:sukun": "\u0AFA",
+ "/gujr:ta": "\u0AA4",
+ "/gujr:tha": "\u0AA5",
+ "/gujr:three": "\u0AE9",
+ "/gujr:three-dotnuktaabove": "\u0AFD",
+ "/gujr:tta": "\u0A9F",
+ "/gujr:ttha": "\u0AA0",
+ "/gujr:two": "\u0AE8",
+ "/gujr:two-circlenuktaabove": "\u0AFF",
+ "/gujr:u": "\u0A89",
+ "/gujr:usign": "\u0AC1",
+ "/gujr:uu": "\u0A8A",
+ "/gujr:uusign": "\u0AC2",
+ "/gujr:va": "\u0AB5",
+ "/gujr:virama": "\u0ACD",
+ "/gujr:visarga": "\u0A83",
+ "/gujr:ya": "\u0AAF",
+ "/gujr:zero": "\u0AE6",
+ "/gujr:zha": "\u0AF9",
+ "/gukatakana": "\u30B0",
+ "/guramusquare": "\u3318",
+ "/guramutonsquare": "\u3319",
+ "/guru:a": "\u0A05",
+ "/guru:aa": "\u0A06",
+ "/guru:aasign": "\u0A3E",
+ "/guru:adakbindisign": "\u0A01",
+ "/guru:addak": "\u0A71",
+ "/guru:ai": "\u0A10",
+ "/guru:aisign": "\u0A48",
+ "/guru:au": "\u0A14",
+ "/guru:ausign": "\u0A4C",
+ "/guru:ba": "\u0A2C",
+ "/guru:bha": "\u0A2D",
+ "/guru:bindisign": "\u0A02",
+ "/guru:ca": "\u0A1A",
+ "/guru:cha": "\u0A1B",
+ "/guru:da": "\u0A26",
+ "/guru:dda": "\u0A21",
+ "/guru:ddha": "\u0A22",
+ "/guru:dha": "\u0A27",
+ "/guru:ee": "\u0A0F",
+ "/guru:eesign": "\u0A47",
+ "/guru:eight": "\u0A6E",
+ "/guru:ekonkar": "\u0A74",
+ "/guru:fa": "\u0A5E",
+ "/guru:five": "\u0A6B",
+ "/guru:four": "\u0A6A",
+ "/guru:ga": "\u0A17",
+ "/guru:gha": "\u0A18",
+ "/guru:ghha": "\u0A5A",
+ "/guru:ha": "\u0A39",
+ "/guru:i": "\u0A07",
+ "/guru:ii": "\u0A08",
+ "/guru:iisign": "\u0A40",
+ "/guru:iri": "\u0A72",
+ "/guru:isign": "\u0A3F",
+ "/guru:ja": "\u0A1C",
+ "/guru:jha": "\u0A1D",
+ "/guru:ka": "\u0A15",
+ "/guru:kha": "\u0A16",
+ "/guru:khha": "\u0A59",
+ "/guru:la": "\u0A32",
+ "/guru:lla": "\u0A33",
+ "/guru:ma": "\u0A2E",
+ "/guru:na": "\u0A28",
+ "/guru:nga": "\u0A19",
+ "/guru:nine": "\u0A6F",
+ "/guru:nna": "\u0A23",
+ "/guru:nukta": "\u0A3C",
+ "/guru:nya": "\u0A1E",
+ "/guru:one": "\u0A67",
+ "/guru:oo": "\u0A13",
+ "/guru:oosign": "\u0A4B",
+ "/guru:pa": "\u0A2A",
+ "/guru:pha": "\u0A2B",
+ "/guru:ra": "\u0A30",
+ "/guru:rra": "\u0A5C",
+ "/guru:sa": "\u0A38",
+ "/guru:seven": "\u0A6D",
+ "/guru:sha": "\u0A36",
+ "/guru:six": "\u0A6C",
+ "/guru:ta": "\u0A24",
+ "/guru:tha": "\u0A25",
+ "/guru:three": "\u0A69",
+ "/guru:tippi": "\u0A70",
+ "/guru:tta": "\u0A1F",
+ "/guru:ttha": "\u0A20",
+ "/guru:two": "\u0A68",
+ "/guru:u": "\u0A09",
+ "/guru:udaatsign": "\u0A51",
+ "/guru:ura": "\u0A73",
+ "/guru:usign": "\u0A41",
+ "/guru:uu": "\u0A0A",
+ "/guru:uusign": "\u0A42",
+ "/guru:va": "\u0A35",
+ "/guru:virama": "\u0A4D",
+ "/guru:visarga": "\u0A03",
+ "/guru:ya": "\u0A2F",
+ "/guru:yakashsign": "\u0A75",
+ "/guru:za": "\u0A5B",
+ "/guru:zero": "\u0A66",
+ "/gyfullwidth": "\u33C9",
+ "/gysquare": "\u33C9",
+ "/h": "\u0068",
+ "/h.inferior": "\u2095",
+ "/haabkhasiancyrillic": "\u04A9",
+ "/haabkhcyr": "\u04A9",
+ "/haaltonearabic": "\u06C1",
+ "/habengali": "\u09B9",
+ "/hacirclekatakana": "\u32E9",
+ "/hacyr": "\u0445",
+ "/hadescendercyrillic": "\u04B3",
+ "/hadeva": "\u0939",
+ "/hafullwidth": "\u33CA",
+ "/hagujarati": "\u0AB9",
+ "/hagurmukhi": "\u0A39",
+ "/hah": "\u062D",
+ "/hah.fina": "\uFEA2",
+ "/hah.init": "\uFEA3",
+ "/hah.init_alefmaksura.fina": "\uFCFF",
+ "/hah.init_jeem.fina": "\uFC17",
+ "/hah.init_jeem.medi": "\uFCA9",
+ "/hah.init_meem.fina": "\uFC18",
+ "/hah.init_meem.medi": "\uFCAA",
+ "/hah.init_yeh.fina": "\uFD00",
+ "/hah.isol": "\uFEA1",
+ "/hah.medi": "\uFEA4",
+ "/hah.medi_alefmaksura.fina": "\uFD1B",
+ "/hah.medi_jeem.medi_yeh.fina": "\uFDBF",
+ "/hah.medi_meem.medi_alefmaksura.fina": "\uFD5B",
+ "/hah.medi_meem.medi_yeh.fina": "\uFD5A",
+ "/hah.medi_yeh.fina": "\uFD1C",
+ "/hahDigitFourBelow": "\u077C",
+ "/hahSmallTahAbove": "\u0772",
+ "/hahSmallTahBelow": "\u076E",
+ "/hahSmallTahTwoDots": "\u076F",
+ "/hahThreeDotsUpBelow": "\u0758",
+ "/hahTwoDotsAbove": "\u0757",
+ "/haharabic": "\u062D",
+ "/hahfinalarabic": "\uFEA2",
+ "/hahhamza": "\u0681",
+ "/hahinitialarabic": "\uFEA3",
+ "/hahiragana": "\u306F",
+ "/hahmedialarabic": "\uFEA4",
+ "/hahookcyr": "\u04FD",
+ "/hahthreedotsabove": "\u0685",
+ "/hahtwodotsvertical": "\u0682",
+ "/haircut": "\u1F487",
+ "/hairspace": "\u200A",
+ "/haitusquare": "\u332A",
+ "/hakatakana": "\u30CF",
+ "/hakatakanahalfwidth": "\uFF8A",
+ "/halantgurmukhi": "\u0A4D",
+ "/halfcircleleftblack": "\u25D6",
+ "/halfcirclerightblack": "\u25D7",
+ "/hamburger": "\u1F354",
+ "/hammer": "\u1F528",
+ "/hammerAndWrench": "\u1F6E0",
+ "/hammerpick": "\u2692",
+ "/hammersickle": "\u262D",
+ "/hamsterFace": "\u1F439",
+ "/hamza": "\u0621",
+ "/hamzaIsol": "\uFE80",
+ "/hamzaabove": "\u0654",
+ "/hamzaarabic": "\u0621",
+ "/hamzabelow": "\u0655",
+ "/hamzadammaarabic": "\u0621",
+ "/hamzadammatanarabic": "\u0621",
+ "/hamzafathaarabic": "\u0621",
+ "/hamzafathatanarabic": "\u0621",
+ "/hamzalowarabic": "\u0621",
+ "/hamzalowkasraarabic": "\u0621",
+ "/hamzalowkasratanarabic": "\u0621",
+ "/hamzasukunarabic": "\u0621",
+ "/handbag": "\u1F45C",
+ "/handtailfishhookturned": "\u02AF",
+ "/hangulchieuchaparen": "\u3217",
+ "/hangulchieuchparen": "\u3209",
+ "/hangulcieucaparen": "\u3216",
+ "/hangulcieucparen": "\u3208",
+ "/hangulcieucuparen": "\u321C",
+ "/hanguldottonemarkdbl": "\u302F",
+ "/hangulfiller": "\u3164",
+ "/hangulhieuhaparen": "\u321B",
+ "/hangulhieuhparen": "\u320D",
+ "/hangulieungaparen": "\u3215",
+ "/hangulieungparen": "\u3207",
+ "/hangulkhieukhaparen": "\u3218",
+ "/hangulkhieukhparen": "\u320A",
+ "/hangulkiyeokaparen": "\u320E",
+ "/hangulkiyeokparen": "\u3200",
+ "/hangulmieumaparen": "\u3212",
+ "/hangulmieumparen": "\u3204",
+ "/hangulnieunaparen": "\u320F",
+ "/hangulnieunparen": "\u3201",
+ "/hangulphieuphaparen": "\u321A",
+ "/hangulphieuphparen": "\u320C",
+ "/hangulpieupaparen": "\u3213",
+ "/hangulpieupparen": "\u3205",
+ "/hangulrieulaparen": "\u3211",
+ "/hangulrieulparen": "\u3203",
+ "/hangulsingledottonemark": "\u302E",
+ "/hangulsiosaparen": "\u3214",
+ "/hangulsiosparen": "\u3206",
+ "/hangulthieuthaparen": "\u3219",
+ "/hangulthieuthparen": "\u320B",
+ "/hangultikeutaparen": "\u3210",
+ "/hangultikeutparen": "\u3202",
+ "/happyPersonRaisingOneHand": "\u1F64B",
+ "/hardDisk": "\u1F5B4",
+ "/hardcyr": "\u044A",
+ "/hardsigncyrillic": "\u044A",
+ "/harpoondownbarbleft": "\u21C3",
+ "/harpoondownbarbright": "\u21C2",
+ "/harpoonleftbarbdown": "\u21BD",
+ "/harpoonleftbarbup": "\u21BC",
+ "/harpoonrightbarbdown": "\u21C1",
+ "/harpoonrightbarbup": "\u21C0",
+ "/harpoonupbarbleft": "\u21BF",
+ "/harpoonupbarbright": "\u21BE",
+ "/hasquare": "\u33CA",
+ "/hastrokecyr": "\u04FF",
+ "/hatafPatah:hb": "\u05B2",
+ "/hatafQamats:hb": "\u05B3",
+ "/hatafSegol:hb": "\u05B1",
+ "/hatafpatah": "\u05B2",
+ "/hatafpatah16": "\u05B2",
+ "/hatafpatah23": "\u05B2",
+ "/hatafpatah2f": "\u05B2",
+ "/hatafpatahhebrew": "\u05B2",
+ "/hatafpatahnarrowhebrew": "\u05B2",
+ "/hatafpatahquarterhebrew": "\u05B2",
+ "/hatafpatahwidehebrew": "\u05B2",
+ "/hatafqamats": "\u05B3",
+ "/hatafqamats1b": "\u05B3",
+ "/hatafqamats28": "\u05B3",
+ "/hatafqamats34": "\u05B3",
+ "/hatafqamatshebrew": "\u05B3",
+ "/hatafqamatsnarrowhebrew": "\u05B3",
+ "/hatafqamatsquarterhebrew": "\u05B3",
+ "/hatafqamatswidehebrew": "\u05B3",
+ "/hatafsegol": "\u05B1",
+ "/hatafsegol17": "\u05B1",
+ "/hatafsegol24": "\u05B1",
+ "/hatafsegol30": "\u05B1",
+ "/hatafsegolhebrew": "\u05B1",
+ "/hatafsegolnarrowhebrew": "\u05B1",
+ "/hatafsegolquarterhebrew": "\u05B1",
+ "/hatafsegolwidehebrew": "\u05B1",
+ "/hatchingChick": "\u1F423",
+ "/haveideographiccircled": "\u3292",
+ "/haveideographicparen": "\u3232",
+ "/hbar": "\u0127",
+ "/hbopomofo": "\u310F",
+ "/hbrevebelow": "\u1E2B",
+ "/hcaron": "\u021F",
+ "/hcedilla": "\u1E29",
+ "/hcircle": "\u24D7",
+ "/hcircumflex": "\u0125",
+ "/hcsquare": "\u1F1A6",
+ "/hdescender": "\u2C68",
+ "/hdieresis": "\u1E27",
+ "/hdot": "\u1E23",
+ "/hdotaccent": "\u1E23",
+ "/hdotbelow": "\u1E25",
+ "/hdrsquare": "\u1F1A7",
+ "/he": "\u05D4",
+ "/he:hb": "\u05D4",
+ "/headphone": "\u1F3A7",
+ "/headstonegraveyard": "\u26FC",
+ "/hearNoEvilMonkey": "\u1F649",
+ "/heart": "\u2665",
+ "/heartArrow": "\u1F498",
+ "/heartDecoration": "\u1F49F",
+ "/heartRibbon": "\u1F49D",
+ "/heartTipOnTheLeft": "\u1F394",
+ "/heartblack": "\u2665",
+ "/heartsuitblack": "\u2665",
+ "/heartsuitwhite": "\u2661",
+ "/heartwhite": "\u2661",
+ "/heavyDollarSign": "\u1F4B2",
+ "/heavyLatinCross": "\u1F547",
+ "/heavydbldashhorz": "\u254D",
+ "/heavydbldashvert": "\u254F",
+ "/heavydn": "\u257B",
+ "/heavydnhorz": "\u2533",
+ "/heavydnleft": "\u2513",
+ "/heavydnright": "\u250F",
+ "/heavyhorz": "\u2501",
+ "/heavyleft": "\u2578",
+ "/heavyleftlightright": "\u257E",
+ "/heavyquaddashhorz": "\u2509",
+ "/heavyquaddashvert": "\u250B",
+ "/heavyright": "\u257A",
+ "/heavytrpldashhorz": "\u2505",
+ "/heavytrpldashvert": "\u2507",
+ "/heavyup": "\u2579",
+ "/heavyuphorz": "\u253B",
+ "/heavyupleft": "\u251B",
+ "/heavyuplightdn": "\u257F",
+ "/heavyupright": "\u2517",
+ "/heavyvert": "\u2503",
+ "/heavyverthorz": "\u254B",
+ "/heavyvertleft": "\u252B",
+ "/heavyvertright": "\u2523",
+ "/hecirclekatakana": "\u32EC",
+ "/hedagesh": "\uFB34",
+ "/hedageshhebrew": "\uFB34",
+ "/hedinterlacedpentagramleft": "\u26E6",
+ "/hedinterlacedpentagramright": "\u26E5",
+ "/heh": "\u0647",
+ "/heh.fina": "\uFEEA",
+ "/heh.init": "\uFEEB",
+ "/heh.init_alefmaksura.fina": "\uFC53",
+ "/heh.init_jeem.fina": "\uFC51",
+ "/heh.init_jeem.medi": "\uFCD7",
+ "/heh.init_meem.fina": "\uFC52",
+ "/heh.init_meem.medi": "\uFCD8",
+ "/heh.init_meem.medi_jeem.medi": "\uFD93",
+ "/heh.init_meem.medi_meem.medi": "\uFD94",
+ "/heh.init_superscriptalef.medi": "\uFCD9",
+ "/heh.init_yeh.fina": "\uFC54",
+ "/heh.isol": "\uFEE9",
+ "/heh.medi": "\uFEEC",
+ "/hehaltonearabic": "\u06C1",
+ "/heharabic": "\u0647",
+ "/hehdoachashmee": "\u06BE",
+ "/hehdoachashmee.fina": "\uFBAB",
+ "/hehdoachashmee.init": "\uFBAC",
+ "/hehdoachashmee.isol": "\uFBAA",
+ "/hehdoachashmee.medi": "\uFBAD",
+ "/hehebrew": "\u05D4",
+ "/hehfinalaltonearabic": "\uFBA7",
+ "/hehfinalalttwoarabic": "\uFEEA",
+ "/hehfinalarabic": "\uFEEA",
+ "/hehgoal": "\u06C1",
+ "/hehgoal.fina": "\uFBA7",
+ "/hehgoal.init": "\uFBA8",
+ "/hehgoal.isol": "\uFBA6",
+ "/hehgoal.medi": "\uFBA9",
+ "/hehgoalhamza": "\u06C2",
+ "/hehhamzaabovefinalarabic": "\uFBA5",
+ "/hehhamzaaboveisolatedarabic": "\uFBA4",
+ "/hehinitialaltonearabic": "\uFBA8",
+ "/hehinitialarabic": "\uFEEB",
+ "/hehinvertedV": "\u06FF",
+ "/hehiragana": "\u3078",
+ "/hehmedialaltonearabic": "\uFBA9",
+ "/hehmedialarabic": "\uFEEC",
+ "/hehyeh": "\u06C0",
+ "/hehyeh.fina": "\uFBA5",
+ "/hehyeh.isol": "\uFBA4",
+ "/heiseierasquare": "\u337B",
+ "/hekatakana": "\u30D8",
+ "/hekatakanahalfwidth": "\uFF8D",
+ "/hekutaarusquare": "\u3336",
+ "/helicopter": "\u1F681",
+ "/helm": "\u2388",
+ "/helmetcrosswhite": "\u26D1",
+ "/heng": "\uA727",
+ "/henghook": "\u0267",
+ "/herb": "\u1F33F",
+ "/hermitianconjugatematrix": "\u22B9",
+ "/herutusquare": "\u3339",
+ "/het": "\u05D7",
+ "/het:hb": "\u05D7",
+ "/heta": "\u0371",
+ "/hethebrew": "\u05D7",
+ "/hewide:hb": "\uFB23",
+ "/hewithmapiq:hb": "\uFB34",
+ "/hfishhookturned": "\u02AE",
+ "/hhalf": "\u2C76",
+ "/hhook": "\u0266",
+ "/hhooksuperior": "\u02B1",
+ "/hhooksupmod": "\u02B1",
+ "/hi-ressquare": "\u1F1A8",
+ "/hibiscus": "\u1F33A",
+ "/hicirclekatakana": "\u32EA",
+ "/hieuhacirclekorean": "\u327B",
+ "/hieuhaparenkorean": "\u321B",
+ "/hieuhcirclekorean": "\u326D",
+ "/hieuhkorean": "\u314E",
+ "/hieuhparenkorean": "\u320D",
+ "/high-heeledShoe": "\u1F460",
+ "/highBrightness": "\u1F506",
+ "/highSpeedTrain": "\u1F684",
+ "/highSpeedTrainWithBulletNose": "\u1F685",
+ "/highhamza": "\u0674",
+ "/highideographiccircled": "\u32A4",
+ "/highvoltage": "\u26A1",
+ "/hihiragana": "\u3072",
+ "/hikatakana": "\u30D2",
+ "/hikatakanahalfwidth": "\uFF8B",
+ "/hira:a": "\u3042",
+ "/hira:asmall": "\u3041",
+ "/hira:ba": "\u3070",
+ "/hira:be": "\u3079",
+ "/hira:bi": "\u3073",
+ "/hira:bo": "\u307C",
+ "/hira:bu": "\u3076",
+ "/hira:da": "\u3060",
+ "/hira:de": "\u3067",
+ "/hira:di": "\u3062",
+ "/hira:digraphyori": "\u309F",
+ "/hira:do": "\u3069",
+ "/hira:du": "\u3065",
+ "/hira:e": "\u3048",
+ "/hira:esmall": "\u3047",
+ "/hira:ga": "\u304C",
+ "/hira:ge": "\u3052",
+ "/hira:gi": "\u304E",
+ "/hira:go": "\u3054",
+ "/hira:gu": "\u3050",
+ "/hira:ha": "\u306F",
+ "/hira:he": "\u3078",
+ "/hira:hi": "\u3072",
+ "/hira:ho": "\u307B",
+ "/hira:hu": "\u3075",
+ "/hira:i": "\u3044",
+ "/hira:ismall": "\u3043",
+ "/hira:iterationhiragana": "\u309D",
+ "/hira:ka": "\u304B",
+ "/hira:kasmall": "\u3095",
+ "/hira:ke": "\u3051",
+ "/hira:kesmall": "\u3096",
+ "/hira:ki": "\u304D",
+ "/hira:ko": "\u3053",
+ "/hira:ku": "\u304F",
+ "/hira:ma": "\u307E",
+ "/hira:me": "\u3081",
+ "/hira:mi": "\u307F",
+ "/hira:mo": "\u3082",
+ "/hira:mu": "\u3080",
+ "/hira:n": "\u3093",
+ "/hira:na": "\u306A",
+ "/hira:ne": "\u306D",
+ "/hira:ni": "\u306B",
+ "/hira:no": "\u306E",
+ "/hira:nu": "\u306C",
+ "/hira:o": "\u304A",
+ "/hira:osmall": "\u3049",
+ "/hira:pa": "\u3071",
+ "/hira:pe": "\u307A",
+ "/hira:pi": "\u3074",
+ "/hira:po": "\u307D",
+ "/hira:pu": "\u3077",
+ "/hira:ra": "\u3089",
+ "/hira:re": "\u308C",
+ "/hira:ri": "\u308A",
+ "/hira:ro": "\u308D",
+ "/hira:ru": "\u308B",
+ "/hira:sa": "\u3055",
+ "/hira:se": "\u305B",
+ "/hira:semivoicedmarkkana": "\u309C",
+ "/hira:semivoicedmarkkanacmb": "\u309A",
+ "/hira:si": "\u3057",
+ "/hira:so": "\u305D",
+ "/hira:su": "\u3059",
+ "/hira:ta": "\u305F",
+ "/hira:te": "\u3066",
+ "/hira:ti": "\u3061",
+ "/hira:to": "\u3068",
+ "/hira:tu": "\u3064",
+ "/hira:tusmall": "\u3063",
+ "/hira:u": "\u3046",
+ "/hira:usmall": "\u3045",
+ "/hira:voicediterationhiragana": "\u309E",
+ "/hira:voicedmarkkana": "\u309B",
+ "/hira:voicedmarkkanacmb": "\u3099",
+ "/hira:vu": "\u3094",
+ "/hira:wa": "\u308F",
+ "/hira:wasmall": "\u308E",
+ "/hira:we": "\u3091",
+ "/hira:wi": "\u3090",
+ "/hira:wo": "\u3092",
+ "/hira:ya": "\u3084",
+ "/hira:yasmall": "\u3083",
+ "/hira:yo": "\u3088",
+ "/hira:yosmall": "\u3087",
+ "/hira:yu": "\u3086",
+ "/hira:yusmall": "\u3085",
+ "/hira:za": "\u3056",
+ "/hira:ze": "\u305C",
+ "/hira:zi": "\u3058",
+ "/hira:zo": "\u305E",
+ "/hira:zu": "\u305A",
+ "/hiriq": "\u05B4",
+ "/hiriq14": "\u05B4",
+ "/hiriq21": "\u05B4",
+ "/hiriq2d": "\u05B4",
+ "/hiriq:hb": "\u05B4",
+ "/hiriqhebrew": "\u05B4",
+ "/hiriqnarrowhebrew": "\u05B4",
+ "/hiriqquarterhebrew": "\u05B4",
+ "/hiriqwidehebrew": "\u05B4",
+ "/historicsite": "\u26EC",
+ "/hlinebelow": "\u1E96",
+ "/hmonospace": "\uFF48",
+ "/hoarmenian": "\u0570",
+ "/hocho": "\u1F52A",
+ "/hocirclekatakana": "\u32ED",
+ "/hohipthai": "\u0E2B",
+ "/hohiragana": "\u307B",
+ "/hokatakana": "\u30DB",
+ "/hokatakanahalfwidth": "\uFF8E",
+ "/holam": "\u05B9",
+ "/holam19": "\u05B9",
+ "/holam26": "\u05B9",
+ "/holam32": "\u05B9",
+ "/holam:hb": "\u05B9",
+ "/holamHaser:hb": "\u05BA",
+ "/holamhebrew": "\u05B9",
+ "/holamnarrowhebrew": "\u05B9",
+ "/holamquarterhebrew": "\u05B9",
+ "/holamwidehebrew": "\u05B9",
+ "/hole": "\u1F573",
+ "/homotic": "\u223B",
+ "/honeyPot": "\u1F36F",
+ "/honeybee": "\u1F41D",
+ "/honokhukthai": "\u0E2E",
+ "/honsquare": "\u333F",
+ "/hook": "\u2440",
+ "/hookabovecomb": "\u0309",
+ "/hookcmb": "\u0309",
+ "/hookpalatalizedbelowcmb": "\u0321",
+ "/hookretroflexbelowcmb": "\u0322",
+ "/hoonsquare": "\u3342",
+ "/hoorusquare": "\u3341",
+ "/horicoptic": "\u03E9",
+ "/horizontalTrafficLight": "\u1F6A5",
+ "/horizontalbar": "\u2015",
+ "/horizontalbarwhitearrowonpedestalup": "\u21EC",
+ "/horizontalmalestroke": "\u26A9",
+ "/horncmb": "\u031B",
+ "/horse": "\u1F40E",
+ "/horseFace": "\u1F434",
+ "/horseRacing": "\u1F3C7",
+ "/hospital": "\u1F3E5",
+ "/hotDog": "\u1F32D",
+ "/hotPepper": "\u1F336",
+ "/hotbeverage": "\u2615",
+ "/hotel": "\u1F3E8",
+ "/hotsprings": "\u2668",
+ "/hourglass": "\u231B",
+ "/hourglassflowings": "\u23F3",
+ "/house": "\u2302",
+ "/houseBuilding": "\u1F3E0",
+ "/houseBuildings": "\u1F3D8",
+ "/houseGarden": "\u1F3E1",
+ "/hpafullwidth": "\u3371",
+ "/hpalatalhook": "\uA795",
+ "/hparen": "\u24A3",
+ "/hparenthesized": "\u24A3",
+ "/hpfullwidth": "\u33CB",
+ "/hryvnia": "\u20B4",
+ "/hsuperior": "\u02B0",
+ "/hsupmod": "\u02B0",
+ "/hturned": "\u0265",
+ "/htypeopencircuit": "\u238F",
+ "/huaraddosquare": "\u3332",
+ "/hucirclekatakana": "\u32EB",
+ "/huhiragana": "\u3075",
+ "/huiitosquare": "\u3333",
+ "/hukatakana": "\u30D5",
+ "/hukatakanahalfwidth": "\uFF8C",
+ "/hundredPoints": "\u1F4AF",
+ "/hundredthousandscmbcyr": "\u0488",
+ "/hungarumlaut": "\u02DD",
+ "/hungarumlautcmb": "\u030B",
+ "/huransquare": "\u3335",
+ "/hushedFace": "\u1F62F",
+ "/hv": "\u0195",
+ "/hwd:a": "\uFFC2",
+ "/hwd:ae": "\uFFC3",
+ "/hwd:blacksquare": "\uFFED",
+ "/hwd:chieuch": "\uFFBA",
+ "/hwd:cieuc": "\uFFB8",
+ "/hwd:downwardsarrow": "\uFFEC",
+ "/hwd:e": "\uFFC7",
+ "/hwd:eo": "\uFFC6",
+ "/hwd:eu": "\uFFDA",
+ "/hwd:formslightvertical": "\uFFE8",
+ "/hwd:hangulfiller": "\uFFA0",
+ "/hwd:hieuh": "\uFFBE",
+ "/hwd:i": "\uFFDC",
+ "/hwd:ideographiccomma": "\uFF64",
+ "/hwd:ideographicfullstop": "\uFF61",
+ "/hwd:ieung": "\uFFB7",
+ "/hwd:kata:a": "\uFF71",
+ "/hwd:kata:asmall": "\uFF67",
+ "/hwd:kata:e": "\uFF74",
+ "/hwd:kata:esmall": "\uFF6A",
+ "/hwd:kata:ha": "\uFF8A",
+ "/hwd:kata:he": "\uFF8D",
+ "/hwd:kata:hi": "\uFF8B",
+ "/hwd:kata:ho": "\uFF8E",
+ "/hwd:kata:hu": "\uFF8C",
+ "/hwd:kata:i": "\uFF72",
+ "/hwd:kata:ismall": "\uFF68",
+ "/hwd:kata:ka": "\uFF76",
+ "/hwd:kata:ke": "\uFF79",
+ "/hwd:kata:ki": "\uFF77",
+ "/hwd:kata:ko": "\uFF7A",
+ "/hwd:kata:ku": "\uFF78",
+ "/hwd:kata:ma": "\uFF8F",
+ "/hwd:kata:me": "\uFF92",
+ "/hwd:kata:mi": "\uFF90",
+ "/hwd:kata:middledot": "\uFF65",
+ "/hwd:kata:mo": "\uFF93",
+ "/hwd:kata:mu": "\uFF91",
+ "/hwd:kata:n": "\uFF9D",
+ "/hwd:kata:na": "\uFF85",
+ "/hwd:kata:ne": "\uFF88",
+ "/hwd:kata:ni": "\uFF86",
+ "/hwd:kata:no": "\uFF89",
+ "/hwd:kata:nu": "\uFF87",
+ "/hwd:kata:o": "\uFF75",
+ "/hwd:kata:osmall": "\uFF6B",
+ "/hwd:kata:prolongedkana": "\uFF70",
+ "/hwd:kata:ra": "\uFF97",
+ "/hwd:kata:re": "\uFF9A",
+ "/hwd:kata:ri": "\uFF98",
+ "/hwd:kata:ro": "\uFF9B",
+ "/hwd:kata:ru": "\uFF99",
+ "/hwd:kata:sa": "\uFF7B",
+ "/hwd:kata:se": "\uFF7E",
+ "/hwd:kata:semi-voiced": "\uFF9F",
+ "/hwd:kata:si": "\uFF7C",
+ "/hwd:kata:so": "\uFF7F",
+ "/hwd:kata:su": "\uFF7D",
+ "/hwd:kata:ta": "\uFF80",
+ "/hwd:kata:te": "\uFF83",
+ "/hwd:kata:ti": "\uFF81",
+ "/hwd:kata:to": "\uFF84",
+ "/hwd:kata:tu": "\uFF82",
+ "/hwd:kata:tusmall": "\uFF6F",
+ "/hwd:kata:u": "\uFF73",
+ "/hwd:kata:usmall": "\uFF69",
+ "/hwd:kata:voiced": "\uFF9E",
+ "/hwd:kata:wa": "\uFF9C",
+ "/hwd:kata:wo": "\uFF66",
+ "/hwd:kata:ya": "\uFF94",
+ "/hwd:kata:yasmall": "\uFF6C",
+ "/hwd:kata:yo": "\uFF96",
+ "/hwd:kata:yosmall": "\uFF6E",
+ "/hwd:kata:yu": "\uFF95",
+ "/hwd:kata:yusmall": "\uFF6D",
+ "/hwd:khieukh": "\uFFBB",
+ "/hwd:kiyeok": "\uFFA1",
+ "/hwd:kiyeoksios": "\uFFA3",
+ "/hwd:leftcornerbracket": "\uFF62",
+ "/hwd:leftwardsarrow": "\uFFE9",
+ "/hwd:mieum": "\uFFB1",
+ "/hwd:nieun": "\uFFA4",
+ "/hwd:nieuncieuc": "\uFFA5",
+ "/hwd:nieunhieuh": "\uFFA6",
+ "/hwd:o": "\uFFCC",
+ "/hwd:oe": "\uFFCF",
+ "/hwd:phieuph": "\uFFBD",
+ "/hwd:pieup": "\uFFB2",
+ "/hwd:pieupsios": "\uFFB4",
+ "/hwd:rieul": "\uFFA9",
+ "/hwd:rieulhieuh": "\uFFB0",
+ "/hwd:rieulkiyeok": "\uFFAA",
+ "/hwd:rieulmieum": "\uFFAB",
+ "/hwd:rieulphieuph": "\uFFAF",
+ "/hwd:rieulpieup": "\uFFAC",
+ "/hwd:rieulsios": "\uFFAD",
+ "/hwd:rieulthieuth": "\uFFAE",
+ "/hwd:rightcornerbracket": "\uFF63",
+ "/hwd:rightwardsarrow": "\uFFEB",
+ "/hwd:sios": "\uFFB5",
+ "/hwd:ssangcieuc": "\uFFB9",
+ "/hwd:ssangkiyeok": "\uFFA2",
+ "/hwd:ssangpieup": "\uFFB3",
+ "/hwd:ssangsios": "\uFFB6",
+ "/hwd:ssangtikeut": "\uFFA8",
+ "/hwd:thieuth": "\uFFBC",
+ "/hwd:tikeut": "\uFFA7",
+ "/hwd:u": "\uFFD3",
+ "/hwd:upwardsarrow": "\uFFEA",
+ "/hwd:wa": "\uFFCD",
+ "/hwd:wae": "\uFFCE",
+ "/hwd:we": "\uFFD5",
+ "/hwd:weo": "\uFFD4",
+ "/hwd:whitecircle": "\uFFEE",
+ "/hwd:wi": "\uFFD6",
+ "/hwd:ya": "\uFFC4",
+ "/hwd:yae": "\uFFC5",
+ "/hwd:ye": "\uFFCB",
+ "/hwd:yeo": "\uFFCA",
+ "/hwd:yi": "\uFFDB",
+ "/hwd:yo": "\uFFD2",
+ "/hwd:yu": "\uFFD7",
+ "/hyphen": "\u002D",
+ "/hyphenationpoint": "\u2027",
+ "/hyphenbullet": "\u2043",
+ "/hyphendbl": "\u2E40",
+ "/hyphendbloblique": "\u2E17",
+ "/hyphendieresis": "\u2E1A",
+ "/hypheninferior": "\uF6E5",
+ "/hyphenminus": "\u002D",
+ "/hyphenmonospace": "\uFF0D",
+ "/hyphensmall": "\uFE63",
+ "/hyphensoft": "\u00AD",
+ "/hyphensuperior": "\uF6E6",
+ "/hyphentwo": "\u2010",
+ "/hypodiastole": "\u2E12",
+ "/hysteresis": "\u238E",
+ "/hzfullwidth": "\u3390",
+ "/i": "\u0069",
+ "/i.superior": "\u2071",
+ "/iacute": "\u00ED",
+ "/iacyrillic": "\u044F",
+ "/iaepigraphic": "\uA7FE",
+ "/ibengali": "\u0987",
+ "/ibopomofo": "\u3127",
+ "/ibreve": "\u012D",
+ "/icaron": "\u01D0",
+ "/iceCream": "\u1F368",
+ "/iceHockeyStickAndPuck": "\u1F3D2",
+ "/iceskate": "\u26F8",
+ "/icircle": "\u24D8",
+ "/icirclekatakana": "\u32D1",
+ "/icircumflex": "\u00EE",
+ "/icyr": "\u0438",
+ "/icyrillic": "\u0456",
+ "/idblgrave": "\u0209",
+ "/idblstruckitalic": "\u2148",
+ "/ideographearthcircle": "\u328F",
+ "/ideographfirecircle": "\u328B",
+ "/ideographicallianceparen": "\u323F",
+ "/ideographiccallparen": "\u323A",
+ "/ideographiccentrecircle": "\u32A5",
+ "/ideographicclose": "\u3006",
+ "/ideographiccomma": "\u3001",
+ "/ideographiccommaleft": "\uFF64",
+ "/ideographiccongratulationparen": "\u3237",
+ "/ideographiccorrectcircle": "\u32A3",
+ "/ideographicdepartingtonemark": "\u302C",
+ "/ideographicearthparen": "\u322F",
+ "/ideographicenteringtonemark": "\u302D",
+ "/ideographicenterpriseparen": "\u323D",
+ "/ideographicexcellentcircle": "\u329D",
+ "/ideographicfestivalparen": "\u3240",
+ "/ideographicfinancialcircle": "\u3296",
+ "/ideographicfinancialparen": "\u3236",
+ "/ideographicfireparen": "\u322B",
+ "/ideographichalffillspace": "\u303F",
+ "/ideographichaveparen": "\u3232",
+ "/ideographichighcircle": "\u32A4",
+ "/ideographiciterationmark": "\u3005",
+ "/ideographiclaborcircle": "\u3298",
+ "/ideographiclaborparen": "\u3238",
+ "/ideographicleftcircle": "\u32A7",
+ "/ideographicleveltonemark": "\u302A",
+ "/ideographiclowcircle": "\u32A6",
+ "/ideographicmedicinecircle": "\u32A9",
+ "/ideographicmetalparen": "\u322E",
+ "/ideographicmoonparen": "\u322A",
+ "/ideographicnameparen": "\u3234",
+ "/ideographicperiod": "\u3002",
+ "/ideographicprintcircle": "\u329E",
+ "/ideographicreachparen": "\u3243",
+ "/ideographicrepresentparen": "\u3239",
+ "/ideographicresourceparen": "\u323E",
+ "/ideographicrightcircle": "\u32A8",
+ "/ideographicrisingtonemark": "\u302B",
+ "/ideographicsecretcircle": "\u3299",
+ "/ideographicselfparen": "\u3242",
+ "/ideographicsocietyparen": "\u3233",
+ "/ideographicspace": "\u3000",
+ "/ideographicspecialparen": "\u3235",
+ "/ideographicstockparen": "\u3231",
+ "/ideographicstudyparen": "\u323B",
+ "/ideographicsunparen": "\u3230",
+ "/ideographicsuperviseparen": "\u323C",
+ "/ideographictelegraphlinefeedseparatorsymbol": "\u3037",
+ "/ideographictelegraphsymbolforhoureight": "\u3360",
+ "/ideographictelegraphsymbolforhoureighteen": "\u336A",
+ "/ideographictelegraphsymbolforhoureleven": "\u3363",
+ "/ideographictelegraphsymbolforhourfifteen": "\u3367",
+ "/ideographictelegraphsymbolforhourfive": "\u335D",
+ "/ideographictelegraphsymbolforhourfour": "\u335C",
+ "/ideographictelegraphsymbolforhourfourteen": "\u3366",
+ "/ideographictelegraphsymbolforhournine": "\u3361",
+ "/ideographictelegraphsymbolforhournineteen": "\u336B",
+ "/ideographictelegraphsymbolforhourone": "\u3359",
+ "/ideographictelegraphsymbolforhourseven": "\u335F",
+ "/ideographictelegraphsymbolforhourseventeen": "\u3369",
+ "/ideographictelegraphsymbolforhoursix": "\u335E",
+ "/ideographictelegraphsymbolforhoursixteen": "\u3368",
+ "/ideographictelegraphsymbolforhourten": "\u3362",
+ "/ideographictelegraphsymbolforhourthirteen": "\u3365",
+ "/ideographictelegraphsymbolforhourthree": "\u335B",
+ "/ideographictelegraphsymbolforhourtwelve": "\u3364",
+ "/ideographictelegraphsymbolforhourtwenty": "\u336C",
+ "/ideographictelegraphsymbolforhourtwentyfour": "\u3370",
+ "/ideographictelegraphsymbolforhourtwentyone": "\u336D",
+ "/ideographictelegraphsymbolforhourtwentythree": "\u336F",
+ "/ideographictelegraphsymbolforhourtwentytwo": "\u336E",
+ "/ideographictelegraphsymbolforhourtwo": "\u335A",
+ "/ideographictelegraphsymbolforhourzero": "\u3358",
+ "/ideographicvariationindicator": "\u303E",
+ "/ideographicwaterparen": "\u322C",
+ "/ideographicwoodparen": "\u322D",
+ "/ideographiczero": "\u3007",
+ "/ideographmetalcircle": "\u328E",
+ "/ideographmooncircle": "\u328A",
+ "/ideographnamecircle": "\u3294",
+ "/ideographsuncircle": "\u3290",
+ "/ideographwatercircle": "\u328C",
+ "/ideographwoodcircle": "\u328D",
+ "/ideva": "\u0907",
+ "/idieresis": "\u00EF",
+ "/idieresisacute": "\u1E2F",
+ "/idieresiscyr": "\u04E5",
+ "/idieresiscyrillic": "\u04E5",
+ "/idotbelow": "\u1ECB",
+ "/idsquare": "\u1F194",
+ "/iebrevecyr": "\u04D7",
+ "/iebrevecyrillic": "\u04D7",
+ "/iecyr": "\u0435",
+ "/iecyrillic": "\u0435",
+ "/iegravecyr": "\u0450",
+ "/iepigraphicsideways": "\uA7F7",
+ "/ieungacirclekorean": "\u3275",
+ "/ieungaparenkorean": "\u3215",
+ "/ieungcirclekorean": "\u3267",
+ "/ieungkorean": "\u3147",
+ "/ieungparenkorean": "\u3207",
+ "/ieungucirclekorean": "\u327E",
+ "/igrave": "\u00EC",
+ "/igravecyr": "\u045D",
+ "/igravedbl": "\u0209",
+ "/igujarati": "\u0A87",
+ "/igurmukhi": "\u0A07",
+ "/ihiragana": "\u3044",
+ "/ihoi": "\u1EC9",
+ "/ihookabove": "\u1EC9",
+ "/iibengali": "\u0988",
+ "/iicyrillic": "\u0438",
+ "/iideva": "\u0908",
+ "/iigujarati": "\u0A88",
+ "/iigurmukhi": "\u0A08",
+ "/iimatragurmukhi": "\u0A40",
+ "/iinvertedbreve": "\u020B",
+ "/iishortcyrillic": "\u0439",
+ "/iivowelsignbengali": "\u09C0",
+ "/iivowelsigndeva": "\u0940",
+ "/iivowelsigngujarati": "\u0AC0",
+ "/ij": "\u0133",
+ "/ikatakana": "\u30A4",
+ "/ikatakanahalfwidth": "\uFF72",
+ "/ikawi": "\uA985",
+ "/ikorean": "\u3163",
+ "/ilde": "\u02DC",
+ "/iluy:hb": "\u05AC",
+ "/iluyhebrew": "\u05AC",
+ "/imacron": "\u012B",
+ "/imacroncyr": "\u04E3",
+ "/imacroncyrillic": "\u04E3",
+ "/image": "\u22B7",
+ "/imageorapproximatelyequal": "\u2253",
+ "/imatragurmukhi": "\u0A3F",
+ "/imonospace": "\uFF49",
+ "/imp": "\u1F47F",
+ "/inboxTray": "\u1F4E5",
+ "/incomingEnvelope": "\u1F4E8",
+ "/increaseFontSize": "\u1F5DA",
+ "/increment": "\u2206",
+ "/indianrupee": "\u20B9",
+ "/infinity": "\u221E",
+ "/information": "\u2139",
+ "/infullwidth": "\u33CC",
+ "/inhibitarabicformshaping": "\u206C",
+ "/inhibitsymmetricswapping": "\u206A",
+ "/iniarmenian": "\u056B",
+ "/iningusquare": "\u3304",
+ "/inmationDeskPerson": "\u1F481",
+ "/inputLatinCapitalLetters": "\u1F520",
+ "/inputLatinLetters": "\u1F524",
+ "/inputLatinSmallLetters": "\u1F521",
+ "/inputNumbers": "\u1F522",
+ "/inputS": "\u1F523",
+ "/insertion": "\u2380",
+ "/integral": "\u222B",
+ "/integralbottom": "\u2321",
+ "/integralbt": "\u2321",
+ "/integralclockwise": "\u2231",
+ "/integralcontour": "\u222E",
+ "/integralcontouranticlockwise": "\u2233",
+ "/integralcontourclockwise": "\u2232",
+ "/integraldbl": "\u222C",
+ "/integralex": "\uF8F5",
+ "/integralextension": "\u23AE",
+ "/integralsurface": "\u222F",
+ "/integraltop": "\u2320",
+ "/integraltp": "\u2320",
+ "/integraltpl": "\u222D",
+ "/integralvolume": "\u2230",
+ "/intercalate": "\u22BA",
+ "/interlinearanchor": "\uFFF9",
+ "/interlinearseparator": "\uFFFA",
+ "/interlinearterminator": "\uFFFB",
+ "/interlockedfemalemale": "\u26A4",
+ "/interrobang": "\u203D",
+ "/interrobanginverted": "\u2E18",
+ "/intersection": "\u2229",
+ "/intersectionarray": "\u22C2",
+ "/intersectiondbl": "\u22D2",
+ "/intisquare": "\u3305",
+ "/invbullet": "\u25D8",
+ "/invcircle": "\u25D9",
+ "/inverteddamma": "\u0657",
+ "/invertedfork": "\u2443",
+ "/invertedpentagram": "\u26E7",
+ "/invertedundertie": "\u2054",
+ "/invisibleplus": "\u2064",
+ "/invisibleseparator": "\u2063",
+ "/invisibletimes": "\u2062",
+ "/invsmileface": "\u263B",
+ "/iocyr": "\u0451",
+ "/iocyrillic": "\u0451",
+ "/iogonek": "\u012F",
+ "/iota": "\u03B9",
+ "/iotaacute": "\u1F77",
+ "/iotaadscript": "\u1FBE",
+ "/iotaasper": "\u1F31",
+ "/iotaasperacute": "\u1F35",
+ "/iotaaspergrave": "\u1F33",
+ "/iotaaspertilde": "\u1F37",
+ "/iotabreve": "\u1FD0",
+ "/iotadieresis": "\u03CA",
+ "/iotadieresisacute": "\u1FD3",
+ "/iotadieresisgrave": "\u1FD2",
+ "/iotadieresistilde": "\u1FD7",
+ "/iotadieresistonos": "\u0390",
+ "/iotafunc": "\u2373",
+ "/iotagrave": "\u1F76",
+ "/iotalatin": "\u0269",
+ "/iotalenis": "\u1F30",
+ "/iotalenisacute": "\u1F34",
+ "/iotalenisgrave": "\u1F32",
+ "/iotalenistilde": "\u1F36",
+ "/iotasub": "\u037A",
+ "/iotatilde": "\u1FD6",
+ "/iotatonos": "\u03AF",
+ "/iotaturned": "\u2129",
+ "/iotaunderlinefunc": "\u2378",
+ "/iotawithmacron": "\u1FD1",
+ "/ipa:Ismall": "\u026A",
+ "/ipa:alpha": "\u0251",
+ "/ipa:ereversed": "\u0258",
+ "/ipa:esh": "\u0283",
+ "/ipa:gamma": "\u0263",
+ "/ipa:glottalstop": "\u0294",
+ "/ipa:gscript": "\u0261",
+ "/ipa:iota": "\u0269",
+ "/ipa:phi": "\u0278",
+ "/ipa:rtail": "\u027D",
+ "/ipa:schwa": "\u0259",
+ "/ipa:upsilon": "\u028A",
+ "/iparen": "\u24A4",
+ "/iparenthesized": "\u24A4",
+ "/irigurmukhi": "\u0A72",
+ "/is": "\uA76D",
+ "/isen-isenpada": "\uA9DF",
+ "/ishortcyr": "\u0439",
+ "/ishortsharptailcyr": "\u048B",
+ "/ismallhiragana": "\u3043",
+ "/ismallkatakana": "\u30A3",
+ "/ismallkatakanahalfwidth": "\uFF68",
+ "/issharbengali": "\u09FA",
+ "/istroke": "\u0268",
+ "/isuperior": "\uF6ED",
+ "/itemideographiccircled": "\u32A0",
+ "/iterationhiragana": "\u309D",
+ "/iterationkatakana": "\u30FD",
+ "/itilde": "\u0129",
+ "/itildebelow": "\u1E2D",
+ "/iubopomofo": "\u3129",
+ "/iucyrillic": "\u044E",
+ "/iufullwidth": "\u337A",
+ "/iukrcyr": "\u0456",
+ "/ivowelsignbengali": "\u09BF",
+ "/ivowelsigndeva": "\u093F",
+ "/ivowelsigngujarati": "\u0ABF",
+ "/izakayaLantern": "\u1F3EE",
+ "/izhitsacyr": "\u0475",
+ "/izhitsacyrillic": "\u0475",
+ "/izhitsadblgravecyrillic": "\u0477",
+ "/izhitsagravedblcyr": "\u0477",
+ "/j": "\u006A",
+ "/j.inferior": "\u2C7C",
+ "/jaarmenian": "\u0571",
+ "/jabengali": "\u099C",
+ "/jackOLantern": "\u1F383",
+ "/jadeva": "\u091C",
+ "/jagujarati": "\u0A9C",
+ "/jagurmukhi": "\u0A1C",
+ "/jamahaprana": "\uA999",
+ "/januarytelegraph": "\u32C0",
+ "/japaneseBeginner": "\u1F530",
+ "/japaneseCastle": "\u1F3EF",
+ "/japaneseDolls": "\u1F38E",
+ "/japaneseGoblin": "\u1F47A",
+ "/japaneseOgre": "\u1F479",
+ "/japanesePostOffice": "\u1F3E3",
+ "/japanesebank": "\u26FB",
+ "/java:a": "\uA984",
+ "/java:ai": "\uA98D",
+ "/java:ba": "\uA9A7",
+ "/java:ca": "\uA995",
+ "/java:da": "\uA9A2",
+ "/java:dda": "\uA99D",
+ "/java:e": "\uA98C",
+ "/java:eight": "\uA9D8",
+ "/java:five": "\uA9D5",
+ "/java:four": "\uA9D4",
+ "/java:ga": "\uA992",
+ "/java:ha": "\uA9B2",
+ "/java:i": "\uA986",
+ "/java:ii": "\uA987",
+ "/java:ja": "\uA997",
+ "/java:ka": "\uA98F",
+ "/java:la": "\uA9AD",
+ "/java:ma": "\uA9A9",
+ "/java:na": "\uA9A4",
+ "/java:nga": "\uA994",
+ "/java:nine": "\uA9D9",
+ "/java:nya": "\uA99A",
+ "/java:o": "\uA98E",
+ "/java:one": "\uA9D1",
+ "/java:pa": "\uA9A5",
+ "/java:ra": "\uA9AB",
+ "/java:sa": "\uA9B1",
+ "/java:seven": "\uA9D7",
+ "/java:six": "\uA9D6",
+ "/java:ta": "\uA9A0",
+ "/java:three": "\uA9D3",
+ "/java:tta": "\uA99B",
+ "/java:two": "\uA9D2",
+ "/java:u": "\uA988",
+ "/java:wa": "\uA9AE",
+ "/java:ya": "\uA9AA",
+ "/java:zero": "\uA9D0",
+ "/jbopomofo": "\u3110",
+ "/jcaron": "\u01F0",
+ "/jcircle": "\u24D9",
+ "/jcircumflex": "\u0135",
+ "/jcrossedtail": "\u029D",
+ "/jdblstruckitalic": "\u2149",
+ "/jdotlessstroke": "\u025F",
+ "/jeans": "\u1F456",
+ "/jecyr": "\u0458",
+ "/jecyrillic": "\u0458",
+ "/jeem": "\u062C",
+ "/jeem.fina": "\uFE9E",
+ "/jeem.init": "\uFE9F",
+ "/jeem.init_alefmaksura.fina": "\uFD01",
+ "/jeem.init_hah.fina": "\uFC15",
+ "/jeem.init_hah.medi": "\uFCA7",
+ "/jeem.init_meem.fina": "\uFC16",
+ "/jeem.init_meem.medi": "\uFCA8",
+ "/jeem.init_meem.medi_hah.medi": "\uFD59",
+ "/jeem.init_yeh.fina": "\uFD02",
+ "/jeem.isol": "\uFE9D",
+ "/jeem.medi": "\uFEA0",
+ "/jeem.medi_alefmaksura.fina": "\uFD1D",
+ "/jeem.medi_hah.medi_alefmaksura.fina": "\uFDA6",
+ "/jeem.medi_hah.medi_yeh.fina": "\uFDBE",
+ "/jeem.medi_meem.medi_alefmaksura.fina": "\uFDA7",
+ "/jeem.medi_meem.medi_hah.fina": "\uFD58",
+ "/jeem.medi_meem.medi_yeh.fina": "\uFDA5",
+ "/jeem.medi_yeh.fina": "\uFD1E",
+ "/jeemabove": "\u06DA",
+ "/jeemarabic": "\u062C",
+ "/jeemfinalarabic": "\uFE9E",
+ "/jeeminitialarabic": "\uFE9F",
+ "/jeemmedialarabic": "\uFEA0",
+ "/jeh": "\u0698",
+ "/jeh.fina": "\uFB8B",
+ "/jeh.isol": "\uFB8A",
+ "/jeharabic": "\u0698",
+ "/jehfinalarabic": "\uFB8B",
+ "/jhabengali": "\u099D",
+ "/jhadeva": "\u091D",
+ "/jhagujarati": "\u0A9D",
+ "/jhagurmukhi": "\u0A1D",
+ "/jheharmenian": "\u057B",
+ "/jis": "\u3004",
+ "/jiterup": "\u2643",
+ "/jmonospace": "\uFF4A",
+ "/jotdiaeresisfunc": "\u2364",
+ "/jotunderlinefunc": "\u235B",
+ "/joystick": "\u1F579",
+ "/jparen": "\u24A5",
+ "/jparenthesized": "\u24A5",
+ "/jstroke": "\u0249",
+ "/jsuperior": "\u02B2",
+ "/jsupmod": "\u02B2",
+ "/jueuicircle": "\u327D",
+ "/julytelegraph": "\u32C6",
+ "/junetelegraph": "\u32C5",
+ "/juno": "\u26B5",
+ "/k": "\u006B",
+ "/k.inferior": "\u2096",
+ "/kaaba": "\u1F54B",
+ "/kaaleutcyr": "\u051F",
+ "/kabashkcyr": "\u04A1",
+ "/kabashkircyrillic": "\u04A1",
+ "/kabengali": "\u0995",
+ "/kacirclekatakana": "\u32D5",
+ "/kacute": "\u1E31",
+ "/kacyr": "\u043A",
+ "/kacyrillic": "\u043A",
+ "/kadescendercyrillic": "\u049B",
+ "/kadeva": "\u0915",
+ "/kaf": "\u05DB",
+ "/kaf.fina": "\uFEDA",
+ "/kaf.init": "\uFEDB",
+ "/kaf.init_alef.fina": "\uFC37",
+ "/kaf.init_alefmaksura.fina": "\uFC3D",
+ "/kaf.init_hah.fina": "\uFC39",
+ "/kaf.init_hah.medi": "\uFCC5",
+ "/kaf.init_jeem.fina": "\uFC38",
+ "/kaf.init_jeem.medi": "\uFCC4",
+ "/kaf.init_khah.fina": "\uFC3A",
+ "/kaf.init_khah.medi": "\uFCC6",
+ "/kaf.init_lam.fina": "\uFC3B",
+ "/kaf.init_lam.medi": "\uFCC7",
+ "/kaf.init_meem.fina": "\uFC3C",
+ "/kaf.init_meem.medi": "\uFCC8",
+ "/kaf.init_meem.medi_meem.medi": "\uFDC3",
+ "/kaf.init_yeh.fina": "\uFC3E",
+ "/kaf.isol": "\uFED9",
+ "/kaf.medi": "\uFEDC",
+ "/kaf.medi_alef.fina": "\uFC80",
+ "/kaf.medi_alefmaksura.fina": "\uFC83",
+ "/kaf.medi_lam.fina": "\uFC81",
+ "/kaf.medi_lam.medi": "\uFCEB",
+ "/kaf.medi_meem.fina": "\uFC82",
+ "/kaf.medi_meem.medi": "\uFCEC",
+ "/kaf.medi_meem.medi_meem.fina": "\uFDBB",
+ "/kaf.medi_meem.medi_yeh.fina": "\uFDB7",
+ "/kaf.medi_yeh.fina": "\uFC84",
+ "/kaf:hb": "\u05DB",
+ "/kafTwoDotsAbove": "\u077F",
+ "/kafarabic": "\u0643",
+ "/kafdagesh": "\uFB3B",
+ "/kafdageshhebrew": "\uFB3B",
+ "/kafdotabove": "\u06AC",
+ "/kaffinalarabic": "\uFEDA",
+ "/kafhebrew": "\u05DB",
+ "/kafinitialarabic": "\uFEDB",
+ "/kafmedialarabic": "\uFEDC",
+ "/kafrafehebrew": "\uFB4D",
+ "/kafring": "\u06AB",
+ "/kafswash": "\u06AA",
+ "/kafthreedotsbelow": "\u06AE",
+ "/kafullwidth": "\u3384",
+ "/kafwide:hb": "\uFB24",
+ "/kafwithdagesh:hb": "\uFB3B",
+ "/kafwithrafe:hb": "\uFB4D",
+ "/kagujarati": "\u0A95",
+ "/kagurmukhi": "\u0A15",
+ "/kahiragana": "\u304B",
+ "/kahookcyr": "\u04C4",
+ "/kahookcyrillic": "\u04C4",
+ "/kairisquare": "\u330B",
+ "/kaisymbol": "\u03D7",
+ "/kakatakana": "\u30AB",
+ "/kakatakanahalfwidth": "\uFF76",
+ "/kamurda": "\uA991",
+ "/kappa": "\u03BA",
+ "/kappa.math": "\u03F0",
+ "/kappasymbolgreek": "\u03F0",
+ "/kapyeounmieumkorean": "\u3171",
+ "/kapyeounphieuphkorean": "\u3184",
+ "/kapyeounpieupkorean": "\u3178",
+ "/kapyeounssangpieupkorean": "\u3179",
+ "/karattosquare": "\u330C",
+ "/karoriisquare": "\u330D",
+ "/kasasak": "\uA990",
+ "/kashida": "\u0640",
+ "/kashidaFina": "\uFE73",
+ "/kashidaautoarabic": "\u0640",
+ "/kashidaautonosidebearingarabic": "\u0640",
+ "/kashmiriyeh": "\u0620",
+ "/kasmallkatakana": "\u30F5",
+ "/kasquare": "\u3384",
+ "/kasra": "\u0650",
+ "/kasraIsol": "\uFE7A",
+ "/kasraMedi": "\uFE7B",
+ "/kasraarabic": "\u0650",
+ "/kasrasmall": "\u061A",
+ "/kasratan": "\u064D",
+ "/kasratanIsol": "\uFE74",
+ "/kasratanarabic": "\u064D",
+ "/kastrokecyr": "\u049F",
+ "/kastrokecyrillic": "\u049F",
+ "/kata:a": "\u30A2",
+ "/kata:asmall": "\u30A1",
+ "/kata:ba": "\u30D0",
+ "/kata:be": "\u30D9",
+ "/kata:bi": "\u30D3",
+ "/kata:bo": "\u30DC",
+ "/kata:bu": "\u30D6",
+ "/kata:da": "\u30C0",
+ "/kata:de": "\u30C7",
+ "/kata:di": "\u30C2",
+ "/kata:digraphkoto": "\u30FF",
+ "/kata:do": "\u30C9",
+ "/kata:doublehyphenkana": "\u30A0",
+ "/kata:du": "\u30C5",
+ "/kata:e": "\u30A8",
+ "/kata:esmall": "\u30A7",
+ "/kata:ga": "\u30AC",
+ "/kata:ge": "\u30B2",
+ "/kata:gi": "\u30AE",
+ "/kata:go": "\u30B4",
+ "/kata:gu": "\u30B0",
+ "/kata:ha": "\u30CF",
+ "/kata:he": "\u30D8",
+ "/kata:hi": "\u30D2",
+ "/kata:ho": "\u30DB",
+ "/kata:hu": "\u30D5",
+ "/kata:i": "\u30A4",
+ "/kata:ismall": "\u30A3",
+ "/kata:iteration": "\u30FD",
+ "/kata:ka": "\u30AB",
+ "/kata:kasmall": "\u30F5",
+ "/kata:ke": "\u30B1",
+ "/kata:kesmall": "\u30F6",
+ "/kata:ki": "\u30AD",
+ "/kata:ko": "\u30B3",
+ "/kata:ku": "\u30AF",
+ "/kata:ma": "\u30DE",
+ "/kata:me": "\u30E1",
+ "/kata:mi": "\u30DF",
+ "/kata:middledot": "\u30FB",
+ "/kata:mo": "\u30E2",
+ "/kata:mu": "\u30E0",
+ "/kata:n": "\u30F3",
+ "/kata:na": "\u30CA",
+ "/kata:ne": "\u30CD",
+ "/kata:ni": "\u30CB",
+ "/kata:no": "\u30CE",
+ "/kata:nu": "\u30CC",
+ "/kata:o": "\u30AA",
+ "/kata:osmall": "\u30A9",
+ "/kata:pa": "\u30D1",
+ "/kata:pe": "\u30DA",
+ "/kata:pi": "\u30D4",
+ "/kata:po": "\u30DD",
+ "/kata:prolongedkana": "\u30FC",
+ "/kata:pu": "\u30D7",
+ "/kata:ra": "\u30E9",
+ "/kata:re": "\u30EC",
+ "/kata:ri": "\u30EA",
+ "/kata:ro": "\u30ED",
+ "/kata:ru": "\u30EB",
+ "/kata:sa": "\u30B5",
+ "/kata:se": "\u30BB",
+ "/kata:si": "\u30B7",
+ "/kata:so": "\u30BD",
+ "/kata:su": "\u30B9",
+ "/kata:ta": "\u30BF",
+ "/kata:te": "\u30C6",
+ "/kata:ti": "\u30C1",
+ "/kata:to": "\u30C8",
+ "/kata:tu": "\u30C4",
+ "/kata:tusmall": "\u30C3",
+ "/kata:u": "\u30A6",
+ "/kata:usmall": "\u30A5",
+ "/kata:va": "\u30F7",
+ "/kata:ve": "\u30F9",
+ "/kata:vi": "\u30F8",
+ "/kata:vo": "\u30FA",
+ "/kata:voicediteration": "\u30FE",
+ "/kata:vu": "\u30F4",
+ "/kata:wa": "\u30EF",
+ "/kata:wasmall": "\u30EE",
+ "/kata:we": "\u30F1",
+ "/kata:wi": "\u30F0",
+ "/kata:wo": "\u30F2",
+ "/kata:ya": "\u30E4",
+ "/kata:yasmall": "\u30E3",
+ "/kata:yo": "\u30E8",
+ "/kata:yosmall": "\u30E7",
+ "/kata:yu": "\u30E6",
+ "/kata:yusmall": "\u30E5",
+ "/kata:za": "\u30B6",
+ "/kata:ze": "\u30BC",
+ "/kata:zi": "\u30B8",
+ "/kata:zo": "\u30BE",
+ "/kata:zu": "\u30BA",
+ "/katahiraprolongmarkhalfwidth": "\uFF70",
+ "/katailcyr": "\u049B",
+ "/kaverticalstrokecyr": "\u049D",
+ "/kaverticalstrokecyrillic": "\u049D",
+ "/kavykainvertedlow": "\u2E45",
+ "/kavykalow": "\u2E47",
+ "/kavykawithdotlow": "\u2E48",
+ "/kavykawithkavykaaboveinvertedlow": "\u2E46",
+ "/kbfullwidth": "\u3385",
+ "/kbopomofo": "\u310E",
+ "/kcalfullwidth": "\u3389",
+ "/kcalsquare": "\u3389",
+ "/kcaron": "\u01E9",
+ "/kcedilla": "\u0137",
+ "/kcircle": "\u24DA",
+ "/kcommaaccent": "\u0137",
+ "/kdescender": "\u2C6A",
+ "/kdiagonalstroke": "\uA743",
+ "/kdotbelow": "\u1E33",
+ "/kecirclekatakana": "\u32D8",
+ "/keesusquare": "\u331C",
+ "/keharmenian": "\u0584",
+ "/keheh": "\u06A9",
+ "/keheh.fina": "\uFB8F",
+ "/keheh.init": "\uFB90",
+ "/keheh.isol": "\uFB8E",
+ "/keheh.medi": "\uFB91",
+ "/kehehDotAbove": "\u0762",
+ "/kehehThreeDotsAbove": "\u0763",
+ "/kehehThreeDotsUpBelow": "\u0764",
+ "/kehehthreedotsbelow": "\u063C",
+ "/kehehtwodotsabove": "\u063B",
+ "/kehiragana": "\u3051",
+ "/kekatakana": "\u30B1",
+ "/kekatakanahalfwidth": "\uFF79",
+ "/kelvin": "\u212A",
+ "/kenarmenian": "\u056F",
+ "/keretconsonant": "\uA9BD",
+ "/kesmallkatakana": "\u30F6",
+ "/key": "\u1F511",
+ "/keyboardAndMouse": "\u1F5A6",
+ "/keycapTen": "\u1F51F",
+ "/kgfullwidth": "\u338F",
+ "/kgreenlandic": "\u0138",
+ "/khabengali": "\u0996",
+ "/khacyrillic": "\u0445",
+ "/khadeva": "\u0916",
+ "/khagujarati": "\u0A96",
+ "/khagurmukhi": "\u0A16",
+ "/khah": "\u062E",
+ "/khah.fina": "\uFEA6",
+ "/khah.init": "\uFEA7",
+ "/khah.init_alefmaksura.fina": "\uFD03",
+ "/khah.init_hah.fina": "\uFC1A",
+ "/khah.init_jeem.fina": "\uFC19",
+ "/khah.init_jeem.medi": "\uFCAB",
+ "/khah.init_meem.fina": "\uFC1B",
+ "/khah.init_meem.medi": "\uFCAC",
+ "/khah.init_yeh.fina": "\uFD04",
+ "/khah.isol": "\uFEA5",
+ "/khah.medi": "\uFEA8",
+ "/khah.medi_alefmaksura.fina": "\uFD1F",
+ "/khah.medi_yeh.fina": "\uFD20",
+ "/khaharabic": "\u062E",
+ "/khahfinalarabic": "\uFEA6",
+ "/khahinitialarabic": "\uFEA7",
+ "/khahmedialarabic": "\uFEA8",
+ "/kheicoptic": "\u03E7",
+ "/khhadeva": "\u0959",
+ "/khhagurmukhi": "\u0A59",
+ "/khieukhacirclekorean": "\u3278",
+ "/khieukhaparenkorean": "\u3218",
+ "/khieukhcirclekorean": "\u326A",
+ "/khieukhkorean": "\u314B",
+ "/khieukhparenkorean": "\u320A",
+ "/khokhaithai": "\u0E02",
+ "/khokhonthai": "\u0E05",
+ "/khokhuatthai": "\u0E03",
+ "/khokhwaithai": "\u0E04",
+ "/khomutthai": "\u0E5B",
+ "/khook": "\u0199",
+ "/khorakhangthai": "\u0E06",
+ "/khzfullwidth": "\u3391",
+ "/khzsquare": "\u3391",
+ "/kicirclekatakana": "\u32D6",
+ "/kihiragana": "\u304D",
+ "/kikatakana": "\u30AD",
+ "/kikatakanahalfwidth": "\uFF77",
+ "/kimono": "\u1F458",
+ "/kindergartenideographiccircled": "\u3245",
+ "/kingblack": "\u265A",
+ "/kingwhite": "\u2654",
+ "/kip": "\u20AD",
+ "/kiroguramusquare": "\u3315",
+ "/kiromeetorusquare": "\u3316",
+ "/kirosquare": "\u3314",
+ "/kirowattosquare": "\u3317",
+ "/kiss": "\u1F48F",
+ "/kissMark": "\u1F48B",
+ "/kissingCatFaceWithClosedEyes": "\u1F63D",
+ "/kissingFace": "\u1F617",
+ "/kissingFaceWithClosedEyes": "\u1F61A",
+ "/kissingFaceWithSmilingEyes": "\u1F619",
+ "/kiyeokacirclekorean": "\u326E",
+ "/kiyeokaparenkorean": "\u320E",
+ "/kiyeokcirclekorean": "\u3260",
+ "/kiyeokkorean": "\u3131",
+ "/kiyeokparenkorean": "\u3200",
+ "/kiyeoksioskorean": "\u3133",
+ "/kjecyr": "\u045C",
+ "/kjecyrillic": "\u045C",
+ "/kkfullwidth": "\u33CD",
+ "/klfullwidth": "\u3398",
+ "/klinebelow": "\u1E35",
+ "/klsquare": "\u3398",
+ "/km2fullwidth": "\u33A2",
+ "/km3fullwidth": "\u33A6",
+ "/kmcapitalfullwidth": "\u33CE",
+ "/kmcubedsquare": "\u33A6",
+ "/kmfullwidth": "\u339E",
+ "/kmonospace": "\uFF4B",
+ "/kmsquaredsquare": "\u33A2",
+ "/knda:a": "\u0C85",
+ "/knda:aa": "\u0C86",
+ "/knda:aasign": "\u0CBE",
+ "/knda:ai": "\u0C90",
+ "/knda:ailength": "\u0CD6",
+ "/knda:aisign": "\u0CC8",
+ "/knda:anusvara": "\u0C82",
+ "/knda:au": "\u0C94",
+ "/knda:ausign": "\u0CCC",
+ "/knda:avagraha": "\u0CBD",
+ "/knda:ba": "\u0CAC",
+ "/knda:bha": "\u0CAD",
+ "/knda:ca": "\u0C9A",
+ "/knda:cha": "\u0C9B",
+ "/knda:da": "\u0CA6",
+ "/knda:dda": "\u0CA1",
+ "/knda:ddha": "\u0CA2",
+ "/knda:dha": "\u0CA7",
+ "/knda:e": "\u0C8E",
+ "/knda:ee": "\u0C8F",
+ "/knda:eesign": "\u0CC7",
+ "/knda:eight": "\u0CEE",
+ "/knda:esign": "\u0CC6",
+ "/knda:fa": "\u0CDE",
+ "/knda:five": "\u0CEB",
+ "/knda:four": "\u0CEA",
+ "/knda:ga": "\u0C97",
+ "/knda:gha": "\u0C98",
+ "/knda:ha": "\u0CB9",
+ "/knda:i": "\u0C87",
+ "/knda:ii": "\u0C88",
+ "/knda:iisign": "\u0CC0",
+ "/knda:isign": "\u0CBF",
+ "/knda:ja": "\u0C9C",
+ "/knda:jha": "\u0C9D",
+ "/knda:jihvamuliya": "\u0CF1",
+ "/knda:ka": "\u0C95",
+ "/knda:kha": "\u0C96",
+ "/knda:la": "\u0CB2",
+ "/knda:length": "\u0CD5",
+ "/knda:lla": "\u0CB3",
+ "/knda:llvocal": "\u0CE1",
+ "/knda:llvocalsign": "\u0CE3",
+ "/knda:lvocal": "\u0C8C",
+ "/knda:lvocalsign": "\u0CE2",
+ "/knda:ma": "\u0CAE",
+ "/knda:na": "\u0CA8",
+ "/knda:nga": "\u0C99",
+ "/knda:nine": "\u0CEF",
+ "/knda:nna": "\u0CA3",
+ "/knda:nukta": "\u0CBC",
+ "/knda:nya": "\u0C9E",
+ "/knda:o": "\u0C92",
+ "/knda:one": "\u0CE7",
+ "/knda:oo": "\u0C93",
+ "/knda:oosign": "\u0CCB",
+ "/knda:osign": "\u0CCA",
+ "/knda:pa": "\u0CAA",
+ "/knda:pha": "\u0CAB",
+ "/knda:ra": "\u0CB0",
+ "/knda:rra": "\u0CB1",
+ "/knda:rrvocal": "\u0CE0",
+ "/knda:rrvocalsign": "\u0CC4",
+ "/knda:rvocal": "\u0C8B",
+ "/knda:rvocalsign": "\u0CC3",
+ "/knda:sa": "\u0CB8",
+ "/knda:seven": "\u0CED",
+ "/knda:sha": "\u0CB6",
+ "/knda:signcandrabindu": "\u0C81",
+ "/knda:signspacingcandrabindu": "\u0C80",
+ "/knda:six": "\u0CEC",
+ "/knda:ssa": "\u0CB7",
+ "/knda:ta": "\u0CA4",
+ "/knda:tha": "\u0CA5",
+ "/knda:three": "\u0CE9",
+ "/knda:tta": "\u0C9F",
+ "/knda:ttha": "\u0CA0",
+ "/knda:two": "\u0CE8",
+ "/knda:u": "\u0C89",
+ "/knda:upadhmaniya": "\u0CF2",
+ "/knda:usign": "\u0CC1",
+ "/knda:uu": "\u0C8A",
+ "/knda:uusign": "\u0CC2",
+ "/knda:va": "\u0CB5",
+ "/knda:virama": "\u0CCD",
+ "/knda:visarga": "\u0C83",
+ "/knda:ya": "\u0CAF",
+ "/knda:zero": "\u0CE6",
+ "/knightblack": "\u265E",
+ "/knightwhite": "\u2658",
+ "/ko:a": "\u314F",
+ "/ko:ae": "\u3150",
+ "/ko:aejungseong": "\u1162",
+ "/ko:aeujungseong": "\u11A3",
+ "/ko:ajungseong": "\u1161",
+ "/ko:aojungseong": "\u1176",
+ "/ko:araea": "\u318D",
+ "/ko:araeae": "\u318E",
+ "/ko:araeaeojungseong": "\u119F",
+ "/ko:araeaijungseong": "\u11A1",
+ "/ko:araeajungseong": "\u119E",
+ "/ko:araeaujungseong": "\u11A0",
+ "/ko:aujungseong": "\u1177",
+ "/ko:ceongchieumchieuchchoseong": "\u1155",
+ "/ko:ceongchieumcieucchoseong": "\u1150",
+ "/ko:ceongchieumsioschoseong": "\u113E",
+ "/ko:ceongchieumssangcieucchoseong": "\u1151",
+ "/ko:ceongchieumssangsioschoseong": "\u113F",
+ "/ko:chieuch": "\u314A",
+ "/ko:chieuchchoseong": "\u110E",
+ "/ko:chieuchhieuhchoseong": "\u1153",
+ "/ko:chieuchjongseong": "\u11BE",
+ "/ko:chieuchkhieukhchoseong": "\u1152",
+ "/ko:chitueumchieuchchoseong": "\u1154",
+ "/ko:chitueumcieucchoseong": "\u114E",
+ "/ko:chitueumsioschoseong": "\u113C",
+ "/ko:chitueumssangcieucchoseong": "\u114F",
+ "/ko:chitueumssangsioschoseong": "\u113D",
+ "/ko:cieuc": "\u3148",
+ "/ko:cieucchoseong": "\u110C",
+ "/ko:cieucieungchoseong": "\u114D",
+ "/ko:cieucjongseong": "\u11BD",
+ "/ko:e": "\u3154",
+ "/ko:ejungseong": "\u1166",
+ "/ko:eo": "\u3153",
+ "/ko:eo_eujungseong": "\u117C",
+ "/ko:eojungseong": "\u1165",
+ "/ko:eoojungseong": "\u117A",
+ "/ko:eoujungseong": "\u117B",
+ "/ko:eu": "\u3161",
+ "/ko:eueujungseong": "\u1196",
+ "/ko:eujungseong": "\u1173",
+ "/ko:euujungseong": "\u1195",
+ "/ko:filler": "\u3164",
+ "/ko:fillerchoseong": "\u115F",
+ "/ko:fillerjungseong": "\u1160",
+ "/ko:hieuh": "\u314E",
+ "/ko:hieuhchoseong": "\u1112",
+ "/ko:hieuhjongseong": "\u11C2",
+ "/ko:hieuhmieumjongseong": "\u11F7",
+ "/ko:hieuhnieunjongseong": "\u11F5",
+ "/ko:hieuhpieupjongseong": "\u11F8",
+ "/ko:hieuhrieuljongseong": "\u11F6",
+ "/ko:i": "\u3163",
+ "/ko:iajungseong": "\u1198",
+ "/ko:iaraeajungseong": "\u119D",
+ "/ko:ieujungseong": "\u119C",
+ "/ko:ieung": "\u3147",
+ "/ko:ieungchieuchchoseong": "\u1149",
+ "/ko:ieungchoseong": "\u110B",
+ "/ko:ieungcieucchoseong": "\u1148",
+ "/ko:ieungjongseong": "\u11BC",
+ "/ko:ieungkhieukhjongseong": "\u11EF",
+ "/ko:ieungkiyeokchoseong": "\u1141",
+ "/ko:ieungkiyeokjongseong": "\u11EC",
+ "/ko:ieungmieumchoseong": "\u1143",
+ "/ko:ieungpansioschoseong": "\u1146",
+ "/ko:ieungphieuphchoseong": "\u114B",
+ "/ko:ieungpieupchoseong": "\u1144",
+ "/ko:ieungsioschoseong": "\u1145",
+ "/ko:ieungssangkiyeokjongseong": "\u11ED",
+ "/ko:ieungthieuthchoseong": "\u114A",
+ "/ko:ieungtikeutchoseong": "\u1142",
+ "/ko:ijungseong": "\u1175",
+ "/ko:iojungseong": "\u119A",
+ "/ko:iujungseong": "\u119B",
+ "/ko:iyajungseong": "\u1199",
+ "/ko:kapyeounmieum": "\u3171",
+ "/ko:kapyeounmieumchoseong": "\u111D",
+ "/ko:kapyeounmieumjongseong": "\u11E2",
+ "/ko:kapyeounphieuph": "\u3184",
+ "/ko:kapyeounphieuphchoseong": "\u1157",
+ "/ko:kapyeounphieuphjongseong": "\u11F4",
+ "/ko:kapyeounpieup": "\u3178",
+ "/ko:kapyeounpieupchoseong": "\u112B",
+ "/ko:kapyeounpieupjongseong": "\u11E6",
+ "/ko:kapyeounrieulchoseong": "\u111B",
+ "/ko:kapyeounssangpieup": "\u3179",
+ "/ko:kapyeounssangpieupchoseong": "\u112C",
+ "/ko:khieukh": "\u314B",
+ "/ko:khieukhchoseong": "\u110F",
+ "/ko:khieukhjongseong": "\u11BF",
+ "/ko:kiyeok": "\u3131",
+ "/ko:kiyeokchieuchjongseong": "\u11FC",
+ "/ko:kiyeokchoseong": "\u1100",
+ "/ko:kiyeokhieuhjongseong": "\u11FE",
+ "/ko:kiyeokjongseong": "\u11A8",
+ "/ko:kiyeokkhieukhjongseong": "\u11FD",
+ "/ko:kiyeoknieunjongseong": "\u11FA",
+ "/ko:kiyeokpieupjongseong": "\u11FB",
+ "/ko:kiyeokrieuljongseong": "\u11C3",
+ "/ko:kiyeoksios": "\u3133",
+ "/ko:kiyeoksiosjongseong": "\u11AA",
+ "/ko:kiyeoksioskiyeokjongseong": "\u11C4",
+ "/ko:kiyeoktikeutchoseong": "\u115A",
+ "/ko:mieum": "\u3141",
+ "/ko:mieumchieuchjongseong": "\u11E0",
+ "/ko:mieumchoseong": "\u1106",
+ "/ko:mieumhieuhjongseong": "\u11E1",
+ "/ko:mieumjongseong": "\u11B7",
+ "/ko:mieumkiyeokjongseong": "\u11DA",
+ "/ko:mieumpansios": "\u3170",
+ "/ko:mieumpansiosjongseong": "\u11DF",
+ "/ko:mieumpieup": "\u316E",
+ "/ko:mieumpieupchoseong": "\u111C",
+ "/ko:mieumpieupjongseong": "\u11DC",
+ "/ko:mieumrieuljongseong": "\u11DB",
+ "/ko:mieumsios": "\u316F",
+ "/ko:mieumsiosjongseong": "\u11DD",
+ "/ko:mieumssangsiosjongseong": "\u11DE",
+ "/ko:nieun": "\u3134",
+ "/ko:nieunchoseong": "\u1102",
+ "/ko:nieuncieuc": "\u3135",
+ "/ko:nieuncieucchoseong": "\u115C",
+ "/ko:nieuncieucjongseong": "\u11AC",
+ "/ko:nieunhieuh": "\u3136",
+ "/ko:nieunhieuhchoseong": "\u115D",
+ "/ko:nieunhieuhjongseong": "\u11AD",
+ "/ko:nieunjongseong": "\u11AB",
+ "/ko:nieunkiyeokchoseong": "\u1113",
+ "/ko:nieunkiyeokjongseong": "\u11C5",
+ "/ko:nieunpansios": "\u3168",
+ "/ko:nieunpansiosjongseong": "\u11C8",
+ "/ko:nieunpieupchoseong": "\u1116",
+ "/ko:nieunsios": "\u3167",
+ "/ko:nieunsioschoseong": "\u115B",
+ "/ko:nieunsiosjongseong": "\u11C7",
+ "/ko:nieunthieuthjongseong": "\u11C9",
+ "/ko:nieuntikeut": "\u3166",
+ "/ko:nieuntikeutchoseong": "\u1115",
+ "/ko:nieuntikeutjongseong": "\u11C6",
+ "/ko:o": "\u3157",
+ "/ko:o_ejungseong": "\u1180",
+ "/ko:o_eojungseong": "\u117F",
+ "/ko:oe": "\u315A",
+ "/ko:oejungseong": "\u116C",
+ "/ko:ojungseong": "\u1169",
+ "/ko:oojungseong": "\u1182",
+ "/ko:oujungseong": "\u1183",
+ "/ko:oyaejungseong": "\u11A7",
+ "/ko:oyajungseong": "\u11A6",
+ "/ko:oyejungseong": "\u1181",
+ "/ko:pansios": "\u317F",
+ "/ko:pansioschoseong": "\u1140",
+ "/ko:pansiosjongseong": "\u11EB",
+ "/ko:phieuph": "\u314D",
+ "/ko:phieuphchoseong": "\u1111",
+ "/ko:phieuphjongseong": "\u11C1",
+ "/ko:phieuphpieupchoseong": "\u1156",
+ "/ko:phieuphpieupjongseong": "\u11F3",
+ "/ko:pieup": "\u3142",
+ "/ko:pieupchieuchchoseong": "\u1128",
+ "/ko:pieupchoseong": "\u1107",
+ "/ko:pieupcieuc": "\u3176",
+ "/ko:pieupcieucchoseong": "\u1127",
+ "/ko:pieuphieuhjongseong": "\u11E5",
+ "/ko:pieupjongseong": "\u11B8",
+ "/ko:pieupkiyeok": "\u3172",
+ "/ko:pieupkiyeokchoseong": "\u111E",
+ "/ko:pieupnieunchoseong": "\u111F",
+ "/ko:pieupphieuphchoseong": "\u112A",
+ "/ko:pieupphieuphjongseong": "\u11E4",
+ "/ko:pieuprieuljongseong": "\u11E3",
+ "/ko:pieupsios": "\u3144",
+ "/ko:pieupsioschoseong": "\u1121",
+ "/ko:pieupsioscieucchoseong": "\u1126",
+ "/ko:pieupsiosjongseong": "\u11B9",
+ "/ko:pieupsioskiyeok": "\u3174",
+ "/ko:pieupsioskiyeokchoseong": "\u1122",
+ "/ko:pieupsiospieupchoseong": "\u1124",
+ "/ko:pieupsiostikeut": "\u3175",
+ "/ko:pieupsiostikeutchoseong": "\u1123",
+ "/ko:pieupssangsioschoseong": "\u1125",
+ "/ko:pieupthieuth": "\u3177",
+ "/ko:pieupthieuthchoseong": "\u1129",
+ "/ko:pieuptikeut": "\u3173",
+ "/ko:pieuptikeutchoseong": "\u1120",
+ "/ko:rieul": "\u3139",
+ "/ko:rieulchoseong": "\u1105",
+ "/ko:rieulhieuh": "\u3140",
+ "/ko:rieulhieuhchoseong": "\u111A",
+ "/ko:rieulhieuhjongseong": "\u11B6",
+ "/ko:rieuljongseong": "\u11AF",
+ "/ko:rieulkapyeounpieupjongseong": "\u11D5",
+ "/ko:rieulkhieukhjongseong": "\u11D8",
+ "/ko:rieulkiyeok": "\u313A",
+ "/ko:rieulkiyeokjongseong": "\u11B0",
+ "/ko:rieulkiyeoksios": "\u3169",
+ "/ko:rieulkiyeoksiosjongseong": "\u11CC",
+ "/ko:rieulmieum": "\u313B",
+ "/ko:rieulmieumjongseong": "\u11B1",
+ "/ko:rieulmieumkiyeokjongseong": "\u11D1",
+ "/ko:rieulmieumsiosjongseong": "\u11D2",
+ "/ko:rieulnieunchoseong": "\u1118",
+ "/ko:rieulnieunjongseong": "\u11CD",
+ "/ko:rieulpansios": "\u316C",
+ "/ko:rieulpansiosjongseong": "\u11D7",
+ "/ko:rieulphieuph": "\u313F",
+ "/ko:rieulphieuphjongseong": "\u11B5",
+ "/ko:rieulpieup": "\u313C",
+ "/ko:rieulpieuphieuhjongseong": "\u11D4",
+ "/ko:rieulpieupjongseong": "\u11B2",
+ "/ko:rieulpieupsios": "\u316B",
+ "/ko:rieulpieupsiosjongseong": "\u11D3",
+ "/ko:rieulsios": "\u313D",
+ "/ko:rieulsiosjongseong": "\u11B3",
+ "/ko:rieulssangsiosjongseong": "\u11D6",
+ "/ko:rieulthieuth": "\u313E",
+ "/ko:rieulthieuthjongseong": "\u11B4",
+ "/ko:rieultikeut": "\u316A",
+ "/ko:rieultikeuthieuhjongseong": "\u11CF",
+ "/ko:rieultikeutjongseong": "\u11CE",
+ "/ko:rieulyeorinhieuh": "\u316D",
+ "/ko:rieulyeorinhieuhjongseong": "\u11D9",
+ "/ko:sios": "\u3145",
+ "/ko:sioschieuchchoseong": "\u1137",
+ "/ko:sioschoseong": "\u1109",
+ "/ko:sioscieuc": "\u317E",
+ "/ko:sioscieucchoseong": "\u1136",
+ "/ko:sioshieuhchoseong": "\u113B",
+ "/ko:siosieungchoseong": "\u1135",
+ "/ko:siosjongseong": "\u11BA",
+ "/ko:sioskhieukhchoseong": "\u1138",
+ "/ko:sioskiyeok": "\u317A",
+ "/ko:sioskiyeokchoseong": "\u112D",
+ "/ko:sioskiyeokjongseong": "\u11E7",
+ "/ko:siosmieumchoseong": "\u1131",
+ "/ko:siosnieun": "\u317B",
+ "/ko:siosnieunchoseong": "\u112E",
+ "/ko:siosphieuphchoseong": "\u113A",
+ "/ko:siospieup": "\u317D",
+ "/ko:siospieupchoseong": "\u1132",
+ "/ko:siospieupjongseong": "\u11EA",
+ "/ko:siospieupkiyeokchoseong": "\u1133",
+ "/ko:siosrieulchoseong": "\u1130",
+ "/ko:siosrieuljongseong": "\u11E9",
+ "/ko:siosssangsioschoseong": "\u1134",
+ "/ko:siosthieuthchoseong": "\u1139",
+ "/ko:siostikeut": "\u317C",
+ "/ko:siostikeutchoseong": "\u112F",
+ "/ko:siostikeutjongseong": "\u11E8",
+ "/ko:ssangaraeajungseong": "\u11A2",
+ "/ko:ssangcieuc": "\u3149",
+ "/ko:ssangcieucchoseong": "\u110D",
+ "/ko:ssanghieuh": "\u3185",
+ "/ko:ssanghieuhchoseong": "\u1158",
+ "/ko:ssangieung": "\u3180",
+ "/ko:ssangieungchoseong": "\u1147",
+ "/ko:ssangieungjongseong": "\u11EE",
+ "/ko:ssangkiyeok": "\u3132",
+ "/ko:ssangkiyeokchoseong": "\u1101",
+ "/ko:ssangkiyeokjongseong": "\u11A9",
+ "/ko:ssangnieun": "\u3165",
+ "/ko:ssangnieunchoseong": "\u1114",
+ "/ko:ssangnieunjongseong": "\u11FF",
+ "/ko:ssangpieup": "\u3143",
+ "/ko:ssangpieupchoseong": "\u1108",
+ "/ko:ssangrieulchoseong": "\u1119",
+ "/ko:ssangrieuljongseong": "\u11D0",
+ "/ko:ssangsios": "\u3146",
+ "/ko:ssangsioschoseong": "\u110A",
+ "/ko:ssangsiosjongseong": "\u11BB",
+ "/ko:ssangtikeut": "\u3138",
+ "/ko:ssangtikeutchoseong": "\u1104",
+ "/ko:thieuth": "\u314C",
+ "/ko:thieuthchoseong": "\u1110",
+ "/ko:thieuthjongseong": "\u11C0",
+ "/ko:tikeut": "\u3137",
+ "/ko:tikeutchoseong": "\u1103",
+ "/ko:tikeutjongseong": "\u11AE",
+ "/ko:tikeutkiyeokchoseong": "\u1117",
+ "/ko:tikeutkiyeokjongseong": "\u11CA",
+ "/ko:tikeutrieulchoseong": "\u115E",
+ "/ko:tikeutrieuljongseong": "\u11CB",
+ "/ko:u": "\u315C",
+ "/ko:uaejungseong": "\u118A",
+ "/ko:uajungseong": "\u1189",
+ "/ko:ueo_eujungseong": "\u118B",
+ "/ko:ujungseong": "\u116E",
+ "/ko:uujungseong": "\u118D",
+ "/ko:uyejungseong": "\u118C",
+ "/ko:wa": "\u3158",
+ "/ko:wae": "\u3159",
+ "/ko:waejungseong": "\u116B",
+ "/ko:wajungseong": "\u116A",
+ "/ko:we": "\u315E",
+ "/ko:wejungseong": "\u1170",
+ "/ko:weo": "\u315D",
+ "/ko:weojungseong": "\u116F",
+ "/ko:wi": "\u315F",
+ "/ko:wijungseong": "\u1171",
+ "/ko:ya": "\u3151",
+ "/ko:yae": "\u3152",
+ "/ko:yaejungseong": "\u1164",
+ "/ko:yajungseong": "\u1163",
+ "/ko:yaojungseong": "\u1178",
+ "/ko:yaujungseong": "\u11A4",
+ "/ko:yayojungseong": "\u1179",
+ "/ko:ye": "\u3156",
+ "/ko:yejungseong": "\u1168",
+ "/ko:yeo": "\u3155",
+ "/ko:yeojungseong": "\u1167",
+ "/ko:yeoojungseong": "\u117D",
+ "/ko:yeorinhieuh": "\u3186",
+ "/ko:yeorinhieuhchoseong": "\u1159",
+ "/ko:yeorinhieuhjongseong": "\u11F9",
+ "/ko:yeoujungseong": "\u117E",
+ "/ko:yeoyajungseong": "\u11A5",
+ "/ko:yesieung": "\u3181",
+ "/ko:yesieungchoseong": "\u114C",
+ "/ko:yesieungjongseong": "\u11F0",
+ "/ko:yesieungpansios": "\u3183",
+ "/ko:yesieungpansiosjongseong": "\u11F2",
+ "/ko:yesieungsios": "\u3182",
+ "/ko:yesieungsiosjongseong": "\u11F1",
+ "/ko:yi": "\u3162",
+ "/ko:yijungseong": "\u1174",
+ "/ko:yiujungseong": "\u1197",
+ "/ko:yo": "\u315B",
+ "/ko:yoi": "\u3189",
+ "/ko:yoijungseong": "\u1188",
+ "/ko:yojungseong": "\u116D",
+ "/ko:yoojungseong": "\u1187",
+ "/ko:yoya": "\u3187",
+ "/ko:yoyae": "\u3188",
+ "/ko:yoyaejungseong": "\u1185",
+ "/ko:yoyajungseong": "\u1184",
+ "/ko:yoyeojungseong": "\u1186",
+ "/ko:yu": "\u3160",
+ "/ko:yuajungseong": "\u118E",
+ "/ko:yuejungseong": "\u1190",
+ "/ko:yueojungseong": "\u118F",
+ "/ko:yui": "\u318C",
+ "/ko:yuijungseong": "\u1194",
+ "/ko:yujungseong": "\u1172",
+ "/ko:yuujungseong": "\u1193",
+ "/ko:yuye": "\u318B",
+ "/ko:yuyejungseong": "\u1192",
+ "/ko:yuyeo": "\u318A",
+ "/ko:yuyeojungseong": "\u1191",
+ "/koala": "\u1F428",
+ "/kobliquestroke": "\uA7A3",
+ "/kocirclekatakana": "\u32D9",
+ "/kohiragana": "\u3053",
+ "/kohmfullwidth": "\u33C0",
+ "/kohmsquare": "\u33C0",
+ "/kokaithai": "\u0E01",
+ "/kokatakana": "\u30B3",
+ "/kokatakanahalfwidth": "\uFF7A",
+ "/kooposquare": "\u331E",
+ "/koppa": "\u03DF",
+ "/koppaarchaic": "\u03D9",
+ "/koppacyr": "\u0481",
+ "/koppacyrillic": "\u0481",
+ "/koreanstandardsymbol": "\u327F",
+ "/koroniscmb": "\u0343",
+ "/korunasquare": "\u331D",
+ "/kotoideographiccircled": "\u3247",
+ "/kpafullwidth": "\u33AA",
+ "/kparen": "\u24A6",
+ "/kparenthesized": "\u24A6",
+ "/kpasquare": "\u33AA",
+ "/kra": "\u0138",
+ "/ksicyr": "\u046F",
+ "/ksicyrillic": "\u046F",
+ "/kstroke": "\uA741",
+ "/kstrokediagonalstroke": "\uA745",
+ "/ktfullwidth": "\u33CF",
+ "/ktsquare": "\u33CF",
+ "/kturned": "\u029E",
+ "/kucirclekatakana": "\u32D7",
+ "/kuhiragana": "\u304F",
+ "/kukatakana": "\u30AF",
+ "/kukatakanahalfwidth": "\uFF78",
+ "/kuroonesquare": "\u331B",
+ "/kuruzeirosquare": "\u331A",
+ "/kvfullwidth": "\u33B8",
+ "/kvsquare": "\u33B8",
+ "/kwfullwidth": "\u33BE",
+ "/kwsquare": "\u33BE",
+ "/kyuriisquare": "\u3312",
+ "/l": "\u006C",
+ "/l.inferior": "\u2097",
+ "/label": "\u1F3F7",
+ "/labengali": "\u09B2",
+ "/laborideographiccircled": "\u3298",
+ "/laborideographicparen": "\u3238",
+ "/lacute": "\u013A",
+ "/ladeva": "\u0932",
+ "/ladyBeetle": "\u1F41E",
+ "/lagujarati": "\u0AB2",
+ "/lagurmukhi": "\u0A32",
+ "/lakkhangyaothai": "\u0E45",
+ "/lam": "\u0644",
+ "/lam.fina": "\uFEDE",
+ "/lam.init": "\uFEDF",
+ "/lam.init_alef.fina": "\uFEFB",
+ "/lam.init_alef.medi_hamzaabove.fina": "\uFEF7",
+ "/lam.init_alef.medi_hamzabelow.fina": "\uFEF9",
+ "/lam.init_alef.medi_maddaabove.fina": "\uFEF5",
+ "/lam.init_alefmaksura.fina": "\uFC43",
+ "/lam.init_hah.fina": "\uFC40",
+ "/lam.init_hah.medi": "\uFCCA",
+ "/lam.init_hah.medi_meem.medi": "\uFDB5",
+ "/lam.init_heh.medi": "\uFCCD",
+ "/lam.init_jeem.fina": "\uFC3F",
+ "/lam.init_jeem.medi": "\uFCC9",
+ "/lam.init_jeem.medi_jeem.medi": "\uFD83",
+ "/lam.init_jeem.medi_meem.medi": "\uFDBA",
+ "/lam.init_khah.fina": "\uFC41",
+ "/lam.init_khah.medi": "\uFCCB",
+ "/lam.init_khah.medi_meem.medi": "\uFD86",
+ "/lam.init_meem.fina": "\uFC42",
+ "/lam.init_meem.medi": "\uFCCC",
+ "/lam.init_meem.medi_hah.medi": "\uFD88",
+ "/lam.init_yeh.fina": "\uFC44",
+ "/lam.isol": "\uFEDD",
+ "/lam.medi": "\uFEE0",
+ "/lam.medi_alef.fina": "\uFEFC",
+ "/lam.medi_alef.medi_hamzaabove.fina": "\uFEF8",
+ "/lam.medi_alef.medi_hamzabelow.fina": "\uFEFA",
+ "/lam.medi_alef.medi_maddaabove.fina": "\uFEF6",
+ "/lam.medi_alefmaksura.fina": "\uFC86",
+ "/lam.medi_hah.medi_alefmaksura.fina": "\uFD82",
+ "/lam.medi_hah.medi_meem.fina": "\uFD80",
+ "/lam.medi_hah.medi_yeh.fina": "\uFD81",
+ "/lam.medi_jeem.medi_jeem.fina": "\uFD84",
+ "/lam.medi_jeem.medi_meem.fina": "\uFDBC",
+ "/lam.medi_jeem.medi_yeh.fina": "\uFDAC",
+ "/lam.medi_khah.medi_meem.fina": "\uFD85",
+ "/lam.medi_meem.fina": "\uFC85",
+ "/lam.medi_meem.medi": "\uFCED",
+ "/lam.medi_meem.medi_hah.fina": "\uFD87",
+ "/lam.medi_meem.medi_yeh.fina": "\uFDAD",
+ "/lam.medi_yeh.fina": "\uFC87",
+ "/lamBar": "\u076A",
+ "/lamVabove": "\u06B5",
+ "/lamalefabove": "\u06D9",
+ "/lamaleffinalarabic": "\uFEFC",
+ "/lamalefhamzaabovefinalarabic": "\uFEF8",
+ "/lamalefhamzaaboveisolatedarabic": "\uFEF7",
+ "/lamalefhamzabelowfinalarabic": "\uFEFA",
+ "/lamalefhamzabelowisolatedarabic": "\uFEF9",
+ "/lamalefisolatedarabic": "\uFEFB",
+ "/lamalefmaddaabovefinalarabic": "\uFEF6",
+ "/lamalefmaddaaboveisolatedarabic": "\uFEF5",
+ "/lamarabic": "\u0644",
+ "/lambda": "\u03BB",
+ "/lambdastroke": "\u019B",
+ "/lamdotabove": "\u06B6",
+ "/lamed": "\u05DC",
+ "/lamed:hb": "\u05DC",
+ "/lameddagesh": "\uFB3C",
+ "/lameddageshhebrew": "\uFB3C",
+ "/lamedhebrew": "\u05DC",
+ "/lamedholam": "\u05DC",
+ "/lamedholamdagesh": "\u05DC",
+ "/lamedholamdageshhebrew": "\u05DC",
+ "/lamedholamhebrew": "\u05DC",
+ "/lamedwide:hb": "\uFB25",
+ "/lamedwithdagesh:hb": "\uFB3C",
+ "/lamfinalarabic": "\uFEDE",
+ "/lamhahinitialarabic": "\uFCCA",
+ "/laminitialarabic": "\uFEDF",
+ "/lamjeeminitialarabic": "\uFCC9",
+ "/lamkhahinitialarabic": "\uFCCB",
+ "/lamlamhehisolatedarabic": "\uFDF2",
+ "/lammedialarabic": "\uFEE0",
+ "/lammeemhahinitialarabic": "\uFD88",
+ "/lammeeminitialarabic": "\uFCCC",
+ "/lammeemjeeminitialarabic": "\uFEDF",
+ "/lammeemkhahinitialarabic": "\uFEDF",
+ "/lamthreedotsabove": "\u06B7",
+ "/lamthreedotsbelow": "\u06B8",
+ "/lanemergeleftblack": "\u26D8",
+ "/lanemergeleftwhite": "\u26D9",
+ "/largeBlueCircle": "\u1F535",
+ "/largeBlueDiamond": "\u1F537",
+ "/largeOrangeDiamond": "\u1F536",
+ "/largeRedCircle": "\u1F534",
+ "/largecircle": "\u25EF",
+ "/largetackdown": "\u27D9",
+ "/largetackup": "\u27D8",
+ "/lari": "\u20BE",
+ "/lastQuarterMoon": "\u1F317",
+ "/lastQuarterMoonFace": "\u1F31C",
+ "/lastquartermoon": "\u263E",
+ "/layar": "\uA982",
+ "/lazysinverted": "\u223E",
+ "/lbar": "\u019A",
+ "/lbbar": "\u2114",
+ "/lbelt": "\u026C",
+ "/lbeltretroflex": "\uA78E",
+ "/lbopomofo": "\u310C",
+ "/lbroken": "\uA747",
+ "/lcaron": "\u013E",
+ "/lcedilla": "\u013C",
+ "/lcircle": "\u24DB",
+ "/lcircumflexbelow": "\u1E3D",
+ "/lcommaaccent": "\u013C",
+ "/lcurl": "\u0234",
+ "/ldblbar": "\u2C61",
+ "/ldot": "\u0140",
+ "/ldotaccent": "\u0140",
+ "/ldotbelow": "\u1E37",
+ "/ldotbelowmacron": "\u1E39",
+ "/leafFlutteringInWind": "\u1F343",
+ "/ledger": "\u1F4D2",
+ "/left-pointingMagnifyingGlass": "\u1F50D",
+ "/leftAngerBubble": "\u1F5EE",
+ "/leftFiveEighthsBlock": "\u258B",
+ "/leftHalfBlock": "\u258C",
+ "/leftHandTelephoneReceiver": "\u1F57B",
+ "/leftLuggage": "\u1F6C5",
+ "/leftOneEighthBlock": "\u258F",
+ "/leftOneQuarterBlock": "\u258E",
+ "/leftSevenEighthsBlock": "\u2589",
+ "/leftSpeechBubble": "\u1F5E8",
+ "/leftThoughtBubble": "\u1F5EC",
+ "/leftThreeEighthsBlock": "\u258D",
+ "/leftThreeQuartersBlock": "\u258A",
+ "/leftWritingHand": "\u1F58E",
+ "/leftangleabovecmb": "\u031A",
+ "/leftarrowoverrightarrow": "\u21C6",
+ "/leftdnheavyrightuplight": "\u2545",
+ "/leftharpoonoverrightharpoon": "\u21CB",
+ "/leftheavyrightdnlight": "\u252D",
+ "/leftheavyrightuplight": "\u2535",
+ "/leftheavyrightvertlight": "\u253D",
+ "/leftideographiccircled": "\u32A7",
+ "/leftlightrightdnheavy": "\u2532",
+ "/leftlightrightupheavy": "\u253A",
+ "/leftlightrightvertheavy": "\u254A",
+ "/lefttackbelowcmb": "\u0318",
+ "/lefttorightembed": "\u202A",
+ "/lefttorightisolate": "\u2066",
+ "/lefttorightmark": "\u200E",
+ "/lefttorightoverride": "\u202D",
+ "/leftupheavyrightdnlight": "\u2543",
+ "/lemon": "\u1F34B",
+ "/lenis": "\u1FBF",
+ "/lenisacute": "\u1FCE",
+ "/lenisgrave": "\u1FCD",
+ "/lenistilde": "\u1FCF",
+ "/leo": "\u264C",
+ "/leopard": "\u1F406",
+ "/less": "\u003C",
+ "/lessbutnotequal": "\u2268",
+ "/lessbutnotequivalent": "\u22E6",
+ "/lessdot": "\u22D6",
+ "/lessequal": "\u2264",
+ "/lessequalorgreater": "\u22DA",
+ "/lessmonospace": "\uFF1C",
+ "/lessorequivalent": "\u2272",
+ "/lessorgreater": "\u2276",
+ "/lessoverequal": "\u2266",
+ "/lesssmall": "\uFE64",
+ "/levelSlider": "\u1F39A",
+ "/lezh": "\u026E",
+ "/lfblock": "\u258C",
+ "/lhacyr": "\u0515",
+ "/lhookretroflex": "\u026D",
+ "/libra": "\u264E",
+ "/ligaturealeflamed:hb": "\uFB4F",
+ "/ligatureoemod": "\uA7F9",
+ "/lightCheckMark": "\u1F5F8",
+ "/lightRail": "\u1F688",
+ "/lightShade": "\u2591",
+ "/lightarcdnleft": "\u256E",
+ "/lightarcdnright": "\u256D",
+ "/lightarcupleft": "\u256F",
+ "/lightarcupright": "\u2570",
+ "/lightdbldashhorz": "\u254C",
+ "/lightdbldashvert": "\u254E",
+ "/lightdiagcross": "\u2573",
+ "/lightdiagupleftdnright": "\u2572",
+ "/lightdiaguprightdnleft": "\u2571",
+ "/lightdn": "\u2577",
+ "/lightdnhorz": "\u252C",
+ "/lightdnleft": "\u2510",
+ "/lightdnright": "\u250C",
+ "/lighthorz": "\u2500",
+ "/lightleft": "\u2574",
+ "/lightleftheavyright": "\u257C",
+ "/lightning": "\u2607",
+ "/lightningMood": "\u1F5F2",
+ "/lightningMoodBubble": "\u1F5F1",
+ "/lightquaddashhorz": "\u2508",
+ "/lightquaddashvert": "\u250A",
+ "/lightright": "\u2576",
+ "/lighttrpldashhorz": "\u2504",
+ "/lighttrpldashvert": "\u2506",
+ "/lightup": "\u2575",
+ "/lightupheavydn": "\u257D",
+ "/lightuphorz": "\u2534",
+ "/lightupleft": "\u2518",
+ "/lightupright": "\u2514",
+ "/lightvert": "\u2502",
+ "/lightverthorz": "\u253C",
+ "/lightvertleft": "\u2524",
+ "/lightvertright": "\u251C",
+ "/lineextensionhorizontal": "\u23AF",
+ "/lineextensionvertical": "\u23D0",
+ "/linemiddledotvertical": "\u237F",
+ "/lineseparator": "\u2028",
+ "/lingsapada": "\uA9C8",
+ "/link": "\u1F517",
+ "/linkedPaperclips": "\u1F587",
+ "/lips": "\u1F5E2",
+ "/lipstick": "\u1F484",
+ "/lira": "\u20A4",
+ "/litre": "\u2113",
+ "/livretournois": "\u20B6",
+ "/liwnarmenian": "\u056C",
+ "/lj": "\u01C9",
+ "/ljecyr": "\u0459",
+ "/ljecyrillic": "\u0459",
+ "/ljekomicyr": "\u0509",
+ "/ll": "\uF6C0",
+ "/lladeva": "\u0933",
+ "/llagujarati": "\u0AB3",
+ "/llinebelow": "\u1E3B",
+ "/llladeva": "\u0934",
+ "/llvocalicbengali": "\u09E1",
+ "/llvocalicdeva": "\u0961",
+ "/llvocalicvowelsignbengali": "\u09E3",
+ "/llvocalicvowelsigndeva": "\u0963",
+ "/llwelsh": "\u1EFB",
+ "/lmacrondot": "\u1E39",
+ "/lmfullwidth": "\u33D0",
+ "/lmiddletilde": "\u026B",
+ "/lmonospace": "\uFF4C",
+ "/lmsquare": "\u33D0",
+ "/lnfullwidth": "\u33D1",
+ "/lochulathai": "\u0E2C",
+ "/lock": "\u1F512",
+ "/lockInkPen": "\u1F50F",
+ "/logfullwidth": "\u33D2",
+ "/logicaland": "\u2227",
+ "/logicalandarray": "\u22C0",
+ "/logicalnot": "\u00AC",
+ "/logicalnotreversed": "\u2310",
+ "/logicalor": "\u2228",
+ "/logicalorarray": "\u22C1",
+ "/lolingthai": "\u0E25",
+ "/lollipop": "\u1F36D",
+ "/longdivision": "\u27CC",
+ "/longovershortmetrical": "\u23D2",
+ "/longovertwoshortsmetrical": "\u23D4",
+ "/longs": "\u017F",
+ "/longs_t": "\uFB05",
+ "/longsdot": "\u1E9B",
+ "/longswithdiagonalstroke": "\u1E9C",
+ "/longswithhighstroke": "\u1E9D",
+ "/longtackleft": "\u27DE",
+ "/longtackright": "\u27DD",
+ "/losslesssquare": "\u1F1A9",
+ "/loudlyCryingFace": "\u1F62D",
+ "/loveHotel": "\u1F3E9",
+ "/loveLetter": "\u1F48C",
+ "/lowBrightness": "\u1F505",
+ "/lowasterisk": "\u204E",
+ "/lowerFiveEighthsBlock": "\u2585",
+ "/lowerHalfBlock": "\u2584",
+ "/lowerLeftBallpointPen": "\u1F58A",
+ "/lowerLeftCrayon": "\u1F58D",
+ "/lowerLeftFountainPen": "\u1F58B",
+ "/lowerLeftPaintbrush": "\u1F58C",
+ "/lowerLeftPencil": "\u1F589",
+ "/lowerOneEighthBlock": "\u2581",
+ "/lowerOneQuarterBlock": "\u2582",
+ "/lowerRightShadowedWhiteCircle": "\u1F53E",
+ "/lowerSevenEighthsBlock": "\u2587",
+ "/lowerThreeEighthsBlock": "\u2583",
+ "/lowerThreeQuartersBlock": "\u2586",
+ "/lowercornerdotright": "\u27D3",
+ "/lowerhalfcircle": "\u25E1",
+ "/lowerhalfcircleinversewhite": "\u25DB",
+ "/lowerquadrantcirculararcleft": "\u25DF",
+ "/lowerquadrantcirculararcright": "\u25DE",
+ "/lowertriangleleft": "\u25FA",
+ "/lowertriangleleftblack": "\u25E3",
+ "/lowertriangleright": "\u25FF",
+ "/lowertrianglerightblack": "\u25E2",
+ "/lowideographiccircled": "\u32A6",
+ "/lowlinecenterline": "\uFE4E",
+ "/lowlinecmb": "\u0332",
+ "/lowlinedashed": "\uFE4D",
+ "/lownumeralsign": "\u0375",
+ "/lowquotedblprime": "\u301F",
+ "/lozenge": "\u25CA",
+ "/lozengedividedbyrulehorizontal": "\u27E0",
+ "/lozengesquare": "\u2311",
+ "/lparen": "\u24A7",
+ "/lparenthesized": "\u24A7",
+ "/lretroflex": "\u026D",
+ "/ls": "\u02AA",
+ "/lslash": "\u0142",
+ "/lsquare": "\u2113",
+ "/lstroke": "\uA749",
+ "/lsuperior": "\uF6EE",
+ "/lsupmod": "\u02E1",
+ "/lt:Alpha": "\u2C6D",
+ "/lt:Alphaturned": "\u2C70",
+ "/lt:Beta": "\uA7B4",
+ "/lt:Chi": "\uA7B3",
+ "/lt:Gamma": "\u0194",
+ "/lt:Iota": "\u0196",
+ "/lt:Omega": "\uA7B6",
+ "/lt:Upsilon": "\u01B1",
+ "/lt:beta": "\uA7B5",
+ "/lt:delta": "\u1E9F",
+ "/lt:omega": "\uA7B7",
+ "/ltshade": "\u2591",
+ "/lttr:bet": "\u2136",
+ "/lttr:dalet": "\u2138",
+ "/lttr:gimel": "\u2137",
+ "/lttr:gscript": "\u210A",
+ "/lturned": "\uA781",
+ "/ltypeopencircuit": "\u2390",
+ "/luhurpada": "\uA9C5",
+ "/lum": "\uA772",
+ "/lungsipada": "\uA9C9",
+ "/luthai": "\u0E26",
+ "/lvocalicbengali": "\u098C",
+ "/lvocalicdeva": "\u090C",
+ "/lvocalicvowelsignbengali": "\u09E2",
+ "/lvocalicvowelsigndeva": "\u0962",
+ "/lxfullwidth": "\u33D3",
+ "/lxsquare": "\u33D3",
+ "/lzed": "\u02AB",
+ "/m": "\u006D",
+ "/m.inferior": "\u2098",
+ "/m2fullwidth": "\u33A1",
+ "/m3fullwidth": "\u33A5",
+ "/mabengali": "\u09AE",
+ "/macirclekatakana": "\u32EE",
+ "/macron": "\u00AF",
+ "/macronbelowcmb": "\u0331",
+ "/macroncmb": "\u0304",
+ "/macronlowmod": "\u02CD",
+ "/macronmod": "\u02C9",
+ "/macronmonospace": "\uFFE3",
+ "/macute": "\u1E3F",
+ "/madda": "\u0653",
+ "/maddaabove": "\u06E4",
+ "/madeva": "\u092E",
+ "/madyapada": "\uA9C4",
+ "/mafullwidth": "\u3383",
+ "/magujarati": "\u0AAE",
+ "/magurmukhi": "\u0A2E",
+ "/mahapakhhebrew": "\u05A4",
+ "/mahapakhlefthebrew": "\u05A4",
+ "/mahhasquare": "\u3345",
+ "/mahiragana": "\u307E",
+ "/mahpach:hb": "\u05A4",
+ "/maichattawalowleftthai": "\uF895",
+ "/maichattawalowrightthai": "\uF894",
+ "/maichattawathai": "\u0E4B",
+ "/maichattawaupperleftthai": "\uF893",
+ "/maieklowleftthai": "\uF88C",
+ "/maieklowrightthai": "\uF88B",
+ "/maiekthai": "\u0E48",
+ "/maiekupperleftthai": "\uF88A",
+ "/maihanakatleftthai": "\uF884",
+ "/maihanakatthai": "\u0E31",
+ "/maikurosquare": "\u3343",
+ "/mairusquare": "\u3344",
+ "/maitaikhuleftthai": "\uF889",
+ "/maitaikhuthai": "\u0E47",
+ "/maitholowleftthai": "\uF88F",
+ "/maitholowrightthai": "\uF88E",
+ "/maithothai": "\u0E49",
+ "/maithoupperleftthai": "\uF88D",
+ "/maitrilowleftthai": "\uF892",
+ "/maitrilowrightthai": "\uF891",
+ "/maitrithai": "\u0E4A",
+ "/maitriupperleftthai": "\uF890",
+ "/maiyamokthai": "\u0E46",
+ "/makatakana": "\u30DE",
+ "/makatakanahalfwidth": "\uFF8F",
+ "/male": "\u2642",
+ "/malefemale": "\u26A5",
+ "/maleideographiccircled": "\u329A",
+ "/malestroke": "\u26A6",
+ "/malestrokemalefemale": "\u26A7",
+ "/man": "\u1F468",
+ "/manAndWomanHoldingHands": "\u1F46B",
+ "/manDancing": "\u1F57A",
+ "/manGuaPiMao": "\u1F472",
+ "/manInBusinessSuitLevitating": "\u1F574",
+ "/manTurban": "\u1F473",
+ "/manat": "\u20BC",
+ "/mansShoe": "\u1F45E",
+ "/mansyonsquare": "\u3347",
+ "/mantelpieceClock": "\u1F570",
+ "/mapleLeaf": "\u1F341",
+ "/maplighthouse": "\u26EF",
+ "/maqaf:hb": "\u05BE",
+ "/maqafhebrew": "\u05BE",
+ "/marchtelegraph": "\u32C2",
+ "/mark": "\u061C",
+ "/markerdottedraisedinterpolation": "\u2E07",
+ "/markerdottedtransposition": "\u2E08",
+ "/markerraisedinterpolation": "\u2E06",
+ "/marknoonghunna": "\u0658",
+ "/marksChapter": "\u1F545",
+ "/marriage": "\u26AD",
+ "/mars": "\u2642",
+ "/marukusquare": "\u3346",
+ "/masoraCircle:hb": "\u05AF",
+ "/masoracirclehebrew": "\u05AF",
+ "/masquare": "\u3383",
+ "/masumark": "\u303C",
+ "/math:bowtie": "\u22C8",
+ "/math:cuberoot": "\u221B",
+ "/math:fourthroot": "\u221C",
+ "/maximize": "\u1F5D6",
+ "/maytelegraph": "\u32C4",
+ "/mbfullwidth": "\u3386",
+ "/mbopomofo": "\u3107",
+ "/mbsmallfullwidth": "\u33D4",
+ "/mbsquare": "\u33D4",
+ "/mcircle": "\u24DC",
+ "/mcubedsquare": "\u33A5",
+ "/mdot": "\u1E41",
+ "/mdotaccent": "\u1E41",
+ "/mdotbelow": "\u1E43",
+ "/measuredangle": "\u2221",
+ "/measuredby": "\u225E",
+ "/meatOnBone": "\u1F356",
+ "/mecirclekatakana": "\u32F1",
+ "/medicineideographiccircled": "\u32A9",
+ "/mediumShade": "\u2592",
+ "/mediumcircleblack": "\u26AB",
+ "/mediumcirclewhite": "\u26AA",
+ "/mediummathematicalspace": "\u205F",
+ "/mediumsmallcirclewhite": "\u26AC",
+ "/meem": "\u0645",
+ "/meem.fina": "\uFEE2",
+ "/meem.init": "\uFEE3",
+ "/meem.init_alefmaksura.fina": "\uFC49",
+ "/meem.init_hah.fina": "\uFC46",
+ "/meem.init_hah.medi": "\uFCCF",
+ "/meem.init_hah.medi_jeem.medi": "\uFD89",
+ "/meem.init_hah.medi_meem.medi": "\uFD8A",
+ "/meem.init_jeem.fina": "\uFC45",
+ "/meem.init_jeem.medi": "\uFCCE",
+ "/meem.init_jeem.medi_hah.medi": "\uFD8C",
+ "/meem.init_jeem.medi_khah.medi": "\uFD92",
+ "/meem.init_jeem.medi_meem.medi": "\uFD8D",
+ "/meem.init_khah.fina": "\uFC47",
+ "/meem.init_khah.medi": "\uFCD0",
+ "/meem.init_khah.medi_jeem.medi": "\uFD8E",
+ "/meem.init_khah.medi_meem.medi": "\uFD8F",
+ "/meem.init_meem.fina": "\uFC48",
+ "/meem.init_meem.medi": "\uFCD1",
+ "/meem.init_yeh.fina": "\uFC4A",
+ "/meem.isol": "\uFEE1",
+ "/meem.medi": "\uFEE4",
+ "/meem.medi_alef.fina": "\uFC88",
+ "/meem.medi_hah.medi_yeh.fina": "\uFD8B",
+ "/meem.medi_jeem.medi_yeh.fina": "\uFDC0",
+ "/meem.medi_khah.medi_yeh.fina": "\uFDB9",
+ "/meem.medi_meem.fina": "\uFC89",
+ "/meem.medi_meem.medi_yeh.fina": "\uFDB1",
+ "/meemDotAbove": "\u0765",
+ "/meemDotBelow": "\u0766",
+ "/meemabove": "\u06E2",
+ "/meemabove.init": "\u06D8",
+ "/meemarabic": "\u0645",
+ "/meembelow": "\u06ED",
+ "/meemfinalarabic": "\uFEE2",
+ "/meeminitialarabic": "\uFEE3",
+ "/meemmedialarabic": "\uFEE4",
+ "/meemmeeminitialarabic": "\uFCD1",
+ "/meemmeemisolatedarabic": "\uFC48",
+ "/meetorusquare": "\u334D",
+ "/megasquare": "\u334B",
+ "/megatonsquare": "\u334C",
+ "/mehiragana": "\u3081",
+ "/meizierasquare": "\u337E",
+ "/mekatakana": "\u30E1",
+ "/mekatakanahalfwidth": "\uFF92",
+ "/melon": "\u1F348",
+ "/mem": "\u05DE",
+ "/mem:hb": "\u05DE",
+ "/memdagesh": "\uFB3E",
+ "/memdageshhebrew": "\uFB3E",
+ "/memhebrew": "\u05DE",
+ "/memo": "\u1F4DD",
+ "/memwithdagesh:hb": "\uFB3E",
+ "/menarmenian": "\u0574",
+ "/menorahNineBranches": "\u1F54E",
+ "/menpostSindhi": "\u06FE",
+ "/mens": "\u1F6B9",
+ "/mepigraphicinverted": "\uA7FD",
+ "/mercha:hb": "\u05A5",
+ "/merchaKefulah:hb": "\u05A6",
+ "/mercury": "\u263F",
+ "/merkhahebrew": "\u05A5",
+ "/merkhakefulahebrew": "\u05A6",
+ "/merkhakefulalefthebrew": "\u05A6",
+ "/merkhalefthebrew": "\u05A5",
+ "/metalideographiccircled": "\u328E",
+ "/metalideographicparen": "\u322E",
+ "/meteg:hb": "\u05BD",
+ "/metro": "\u1F687",
+ "/mgfullwidth": "\u338E",
+ "/mhook": "\u0271",
+ "/mhzfullwidth": "\u3392",
+ "/mhzsquare": "\u3392",
+ "/micirclekatakana": "\u32EF",
+ "/microphone": "\u1F3A4",
+ "/microscope": "\u1F52C",
+ "/middledotkatakanahalfwidth": "\uFF65",
+ "/middot": "\u00B7",
+ "/mieumacirclekorean": "\u3272",
+ "/mieumaparenkorean": "\u3212",
+ "/mieumcirclekorean": "\u3264",
+ "/mieumkorean": "\u3141",
+ "/mieumpansioskorean": "\u3170",
+ "/mieumparenkorean": "\u3204",
+ "/mieumpieupkorean": "\u316E",
+ "/mieumsioskorean": "\u316F",
+ "/mihiragana": "\u307F",
+ "/mikatakana": "\u30DF",
+ "/mikatakanahalfwidth": "\uFF90",
+ "/mikuronsquare": "\u3348",
+ "/milfullwidth": "\u33D5",
+ "/militaryMedal": "\u1F396",
+ "/milkyWay": "\u1F30C",
+ "/mill": "\u20A5",
+ "/millionscmbcyr": "\u0489",
+ "/millisecond": "\u2034",
+ "/millisecondreversed": "\u2037",
+ "/minibus": "\u1F690",
+ "/minidisc": "\u1F4BD",
+ "/minimize": "\u1F5D5",
+ "/minus": "\u2212",
+ "/minus.inferior": "\u208B",
+ "/minus.superior": "\u207B",
+ "/minusbelowcmb": "\u0320",
+ "/minuscircle": "\u2296",
+ "/minusmod": "\u02D7",
+ "/minusplus": "\u2213",
+ "/minussignmod": "\u02D7",
+ "/minustilde": "\u2242",
+ "/minute": "\u2032",
+ "/minutereversed": "\u2035",
+ "/miribaarusquare": "\u334A",
+ "/mirisquare": "\u3349",
+ "/misc:baby": "\u1F476",
+ "/misc:bell": "\u1F514",
+ "/misc:dash": "\u1F4A8",
+ "/misc:decimalseparator": "\u2396",
+ "/misc:diamondblack": "\u2666",
+ "/misc:diamondwhite": "\u2662",
+ "/misc:ear": "\u1F442",
+ "/misc:om": "\u1F549",
+ "/misc:ring": "\u1F48D",
+ "/misra": "\u060F",
+ "/mlfullwidth": "\u3396",
+ "/mlonglegturned": "\u0270",
+ "/mlsquare": "\u3396",
+ "/mlym:a": "\u0D05",
+ "/mlym:aa": "\u0D06",
+ "/mlym:aasign": "\u0D3E",
+ "/mlym:ai": "\u0D10",
+ "/mlym:aisign": "\u0D48",
+ "/mlym:anusvarasign": "\u0D02",
+ "/mlym:archaicii": "\u0D5F",
+ "/mlym:au": "\u0D14",
+ "/mlym:aulength": "\u0D57",
+ "/mlym:ausign": "\u0D4C",
+ "/mlym:avagrahasign": "\u0D3D",
+ "/mlym:ba": "\u0D2C",
+ "/mlym:bha": "\u0D2D",
+ "/mlym:ca": "\u0D1A",
+ "/mlym:candrabindusign": "\u0D01",
+ "/mlym:cha": "\u0D1B",
+ "/mlym:circularviramasign": "\u0D3C",
+ "/mlym:combininganusvaraabovesign": "\u0D00",
+ "/mlym:da": "\u0D26",
+ "/mlym:date": "\u0D79",
+ "/mlym:dda": "\u0D21",
+ "/mlym:ddha": "\u0D22",
+ "/mlym:dha": "\u0D27",
+ "/mlym:dotreph": "\u0D4E",
+ "/mlym:e": "\u0D0E",
+ "/mlym:ee": "\u0D0F",
+ "/mlym:eesign": "\u0D47",
+ "/mlym:eight": "\u0D6E",
+ "/mlym:esign": "\u0D46",
+ "/mlym:five": "\u0D6B",
+ "/mlym:four": "\u0D6A",
+ "/mlym:ga": "\u0D17",
+ "/mlym:gha": "\u0D18",
+ "/mlym:ha": "\u0D39",
+ "/mlym:i": "\u0D07",
+ "/mlym:ii": "\u0D08",
+ "/mlym:iisign": "\u0D40",
+ "/mlym:isign": "\u0D3F",
+ "/mlym:ja": "\u0D1C",
+ "/mlym:jha": "\u0D1D",
+ "/mlym:ka": "\u0D15",
+ "/mlym:kchillu": "\u0D7F",
+ "/mlym:kha": "\u0D16",
+ "/mlym:la": "\u0D32",
+ "/mlym:lchillu": "\u0D7D",
+ "/mlym:lla": "\u0D33",
+ "/mlym:llchillu": "\u0D7E",
+ "/mlym:llla": "\u0D34",
+ "/mlym:lllchillu": "\u0D56",
+ "/mlym:llvocal": "\u0D61",
+ "/mlym:llvocalsign": "\u0D63",
+ "/mlym:lvocal": "\u0D0C",
+ "/mlym:lvocalsign": "\u0D62",
+ "/mlym:ma": "\u0D2E",
+ "/mlym:mchillu": "\u0D54",
+ "/mlym:na": "\u0D28",
+ "/mlym:nchillu": "\u0D7B",
+ "/mlym:nga": "\u0D19",
+ "/mlym:nine": "\u0D6F",
+ "/mlym:nna": "\u0D23",
+ "/mlym:nnchillu": "\u0D7A",
+ "/mlym:nnna": "\u0D29",
+ "/mlym:nya": "\u0D1E",
+ "/mlym:o": "\u0D12",
+ "/mlym:one": "\u0D67",
+ "/mlym:oneeighth": "\u0D77",
+ "/mlym:onefifth": "\u0D5E",
+ "/mlym:onefortieth": "\u0D59",
+ "/mlym:onehalf": "\u0D74",
+ "/mlym:onehundred": "\u0D71",
+ "/mlym:oneone-hundred-and-sixtieth": "\u0D58",
+ "/mlym:onequarter": "\u0D73",
+ "/mlym:onesixteenth": "\u0D76",
+ "/mlym:onetenth": "\u0D5C",
+ "/mlym:onethousand": "\u0D72",
+ "/mlym:onetwentieth": "\u0D5B",
+ "/mlym:oo": "\u0D13",
+ "/mlym:oosign": "\u0D4B",
+ "/mlym:osign": "\u0D4A",
+ "/mlym:pa": "\u0D2A",
+ "/mlym:parasign": "\u0D4F",
+ "/mlym:pha": "\u0D2B",
+ "/mlym:ra": "\u0D30",
+ "/mlym:rra": "\u0D31",
+ "/mlym:rrchillu": "\u0D7C",
+ "/mlym:rrvocal": "\u0D60",
+ "/mlym:rrvocalsign": "\u0D44",
+ "/mlym:rvocal": "\u0D0B",
+ "/mlym:rvocalsign": "\u0D43",
+ "/mlym:sa": "\u0D38",
+ "/mlym:seven": "\u0D6D",
+ "/mlym:sha": "\u0D36",
+ "/mlym:six": "\u0D6C",
+ "/mlym:ssa": "\u0D37",
+ "/mlym:ta": "\u0D24",
+ "/mlym:ten": "\u0D70",
+ "/mlym:tha": "\u0D25",
+ "/mlym:three": "\u0D69",
+ "/mlym:threeeightieths": "\u0D5A",
+ "/mlym:threequarters": "\u0D75",
+ "/mlym:threesixteenths": "\u0D78",
+ "/mlym:threetwentieths": "\u0D5D",
+ "/mlym:tta": "\u0D1F",
+ "/mlym:ttha": "\u0D20",
+ "/mlym:ttta": "\u0D3A",
+ "/mlym:two": "\u0D68",
+ "/mlym:u": "\u0D09",
+ "/mlym:usign": "\u0D41",
+ "/mlym:uu": "\u0D0A",
+ "/mlym:uusign": "\u0D42",
+ "/mlym:va": "\u0D35",
+ "/mlym:verticalbarviramasign": "\u0D3B",
+ "/mlym:viramasign": "\u0D4D",
+ "/mlym:visargasign": "\u0D03",
+ "/mlym:ya": "\u0D2F",
+ "/mlym:ychillu": "\u0D55",
+ "/mlym:zero": "\u0D66",
+ "/mm2fullwidth": "\u339F",
+ "/mm3fullwidth": "\u33A3",
+ "/mmcubedsquare": "\u33A3",
+ "/mmfullwidth": "\u339C",
+ "/mmonospace": "\uFF4D",
+ "/mmsquaredsquare": "\u339F",
+ "/mobilePhone": "\u1F4F1",
+ "/mobilePhoneOff": "\u1F4F4",
+ "/mobilePhoneRightwardsArrowAtLeft": "\u1F4F2",
+ "/mocirclekatakana": "\u32F2",
+ "/models": "\u22A7",
+ "/mohiragana": "\u3082",
+ "/mohmfullwidth": "\u33C1",
+ "/mohmsquare": "\u33C1",
+ "/mokatakana": "\u30E2",
+ "/mokatakanahalfwidth": "\uFF93",
+ "/molfullwidth": "\u33D6",
+ "/molsquare": "\u33D6",
+ "/momathai": "\u0E21",
+ "/moneyBag": "\u1F4B0",
+ "/moneyWings": "\u1F4B8",
+ "/mong:a": "\u1820",
+ "/mong:aaligali": "\u1887",
+ "/mong:ahaligali": "\u1897",
+ "/mong:ang": "\u1829",
+ "/mong:angsibe": "\u1862",
+ "/mong:angtodo": "\u184A",
+ "/mong:anusvaraonealigali": "\u1880",
+ "/mong:ba": "\u182A",
+ "/mong:baludaaligali": "\u1885",
+ "/mong:baludaaligalithree": "\u1886",
+ "/mong:batodo": "\u184B",
+ "/mong:bhamanchualigali": "\u18A8",
+ "/mong:birga": "\u1800",
+ "/mong:caaligali": "\u188B",
+ "/mong:camanchualigali": "\u189C",
+ "/mong:cha": "\u1834",
+ "/mong:chasibe": "\u1871",
+ "/mong:chatodo": "\u1852",
+ "/mong:chi": "\u1842",
+ "/mong:colon": "\u1804",
+ "/mong:comma": "\u1802",
+ "/mong:commamanchu": "\u1808",
+ "/mong:cyamanchualigali": "\u18A3",
+ "/mong:da": "\u1833",
+ "/mong:daaligali": "\u1891",
+ "/mong:dagalgaaligali": "\u18A9",
+ "/mong:damarualigali": "\u1882",
+ "/mong:dasibe": "\u1869",
+ "/mong:datodo": "\u1851",
+ "/mong:ddaaligali": "\u188E",
+ "/mong:ddhamanchualigali": "\u189F",
+ "/mong:dhamanchualigali": "\u18A1",
+ "/mong:dzatodo": "\u185C",
+ "/mong:e": "\u1821",
+ "/mong:ee": "\u1827",
+ "/mong:eight": "\u1818",
+ "/mong:ellipsis": "\u1801",
+ "/mong:esibe": "\u185D",
+ "/mong:etodo": "\u1844",
+ "/mong:fa": "\u1839",
+ "/mong:famanchu": "\u1876",
+ "/mong:fasibe": "\u186B",
+ "/mong:five": "\u1815",
+ "/mong:four": "\u1814",
+ "/mong:fourdots": "\u1805",
+ "/mong:freevariationselectorone": "\u180B",
+ "/mong:freevariationselectorthree": "\u180D",
+ "/mong:freevariationselectortwo": "\u180C",
+ "/mong:ga": "\u182D",
+ "/mong:gaasibe": "\u186C",
+ "/mong:gaatodo": "\u1858",
+ "/mong:gasibe": "\u1864",
+ "/mong:gatodo": "\u184E",
+ "/mong:ghamanchualigali": "\u189A",
+ "/mong:haa": "\u183E",
+ "/mong:haasibe": "\u186D",
+ "/mong:haatodo": "\u1859",
+ "/mong:hasibe": "\u1865",
+ "/mong:i": "\u1822",
+ "/mong:ialigali": "\u1888",
+ "/mong:imanchu": "\u1873",
+ "/mong:isibe": "\u185E",
+ "/mong:itodo": "\u1845",
+ "/mong:iysibe": "\u185F",
+ "/mong:ja": "\u1835",
+ "/mong:jasibe": "\u186A",
+ "/mong:jatodo": "\u1853",
+ "/mong:jhamanchualigali": "\u189D",
+ "/mong:jiatodo": "\u185A",
+ "/mong:ka": "\u183A",
+ "/mong:kaaligali": "\u1889",
+ "/mong:kamanchu": "\u1874",
+ "/mong:kasibe": "\u1863",
+ "/mong:katodo": "\u1857",
+ "/mong:kha": "\u183B",
+ "/mong:la": "\u182F",
+ "/mong:lha": "\u1840",
+ "/mong:lhamanchualigali": "\u18AA",
+ "/mong:longvowelsigntodo": "\u1843",
+ "/mong:ma": "\u182E",
+ "/mong:matodo": "\u184F",
+ "/mong:na": "\u1828",
+ "/mong:ngaaligali": "\u188A",
+ "/mong:ngamanchualigali": "\u189B",
+ "/mong:niatodo": "\u185B",
+ "/mong:nine": "\u1819",
+ "/mong:nirugu": "\u180A",
+ "/mong:nnaaligali": "\u188F",
+ "/mong:o": "\u1823",
+ "/mong:oe": "\u1825",
+ "/mong:oetodo": "\u1848",
+ "/mong:one": "\u1811",
+ "/mong:otodo": "\u1846",
+ "/mong:pa": "\u182B",
+ "/mong:paaligali": "\u1892",
+ "/mong:pasibe": "\u1866",
+ "/mong:patodo": "\u184C",
+ "/mong:period": "\u1803",
+ "/mong:periodmanchu": "\u1809",
+ "/mong:phaaligali": "\u1893",
+ "/mong:qa": "\u182C",
+ "/mong:qatodo": "\u184D",
+ "/mong:ra": "\u1837",
+ "/mong:raasibe": "\u1870",
+ "/mong:ramanchu": "\u1875",
+ "/mong:sa": "\u1830",
+ "/mong:seven": "\u1817",
+ "/mong:sha": "\u1831",
+ "/mong:shasibe": "\u1867",
+ "/mong:six": "\u1816",
+ "/mong:softhyphentodo": "\u1806",
+ "/mong:ssaaligali": "\u1894",
+ "/mong:ssamanchualigali": "\u18A2",
+ "/mong:syllableboundarymarkersibe": "\u1807",
+ "/mong:ta": "\u1832",
+ "/mong:taaligali": "\u1890",
+ "/mong:tamanchualigali": "\u18A0",
+ "/mong:tasibe": "\u1868",
+ "/mong:tatodo": "\u1850",
+ "/mong:tatodoaligali": "\u1898",
+ "/mong:three": "\u1813",
+ "/mong:tsa": "\u183C",
+ "/mong:tsasibe": "\u186E",
+ "/mong:tsatodo": "\u1854",
+ "/mong:ttaaligali": "\u188C",
+ "/mong:ttamanchualigali": "\u189E",
+ "/mong:tthaaligali": "\u188D",
+ "/mong:two": "\u1812",
+ "/mong:u": "\u1824",
+ "/mong:ualigalihalf": "\u18A6",
+ "/mong:ubadamaaligali": "\u1883",
+ "/mong:ubadamaaligaliinverted": "\u1884",
+ "/mong:ue": "\u1826",
+ "/mong:uesibe": "\u1860",
+ "/mong:uetodo": "\u1849",
+ "/mong:usibe": "\u1861",
+ "/mong:utodo": "\u1847",
+ "/mong:visargaonealigali": "\u1881",
+ "/mong:vowelseparator": "\u180E",
+ "/mong:wa": "\u1838",
+ "/mong:watodo": "\u1856",
+ "/mong:ya": "\u1836",
+ "/mong:yaaligalihalf": "\u18A7",
+ "/mong:yatodo": "\u1855",
+ "/mong:za": "\u183D",
+ "/mong:zaaligali": "\u1896",
+ "/mong:zamanchualigali": "\u18A5",
+ "/mong:zasibe": "\u186F",
+ "/mong:zero": "\u1810",
+ "/mong:zhaaligali": "\u1895",
+ "/mong:zhamanchu": "\u1877",
+ "/mong:zhamanchualigali": "\u18A4",
+ "/mong:zhasibe": "\u1872",
+ "/mong:zhatodoaligali": "\u1899",
+ "/mong:zhi": "\u1841",
+ "/mong:zra": "\u183F",
+ "/monkey": "\u1F412",
+ "/monkeyFace": "\u1F435",
+ "/monogramyang": "\u268A",
+ "/monogramyin": "\u268B",
+ "/monorail": "\u1F69D",
+ "/monostable": "\u238D",
+ "/moodBubble": "\u1F5F0",
+ "/moonViewingCeremony": "\u1F391",
+ "/moonideographiccircled": "\u328A",
+ "/moonideographicparen": "\u322A",
+ "/moonlilithblack": "\u26B8",
+ "/mosque": "\u1F54C",
+ "/motorBoat": "\u1F6E5",
+ "/motorScooter": "\u1F6F5",
+ "/motorway": "\u1F6E3",
+ "/mountFuji": "\u1F5FB",
+ "/mountain": "\u26F0",
+ "/mountainBicyclist": "\u1F6B5",
+ "/mountainCableway": "\u1F6A0",
+ "/mountainRailway": "\u1F69E",
+ "/mouse": "\u1F401",
+ "/mouseFace": "\u1F42D",
+ "/mouth": "\u1F444",
+ "/movers2fullwidth": "\u33A8",
+ "/moversfullwidth": "\u33A7",
+ "/moverssquare": "\u33A7",
+ "/moverssquaredsquare": "\u33A8",
+ "/movieCamera": "\u1F3A5",
+ "/moyai": "\u1F5FF",
+ "/mpafullwidth": "\u33AB",
+ "/mparen": "\u24A8",
+ "/mparenthesized": "\u24A8",
+ "/mpasquare": "\u33AB",
+ "/msfullwidth": "\u33B3",
+ "/mssquare": "\u33B3",
+ "/msuperior": "\uF6EF",
+ "/mturned": "\u026F",
+ "/mu": "\u00B5",
+ "/mu.math": "\u00B5",
+ "/mu1": "\u00B5",
+ "/muafullwidth": "\u3382",
+ "/muasquare": "\u3382",
+ "/muchgreater": "\u226B",
+ "/muchless": "\u226A",
+ "/mucirclekatakana": "\u32F0",
+ "/muffullwidth": "\u338C",
+ "/mufsquare": "\u338C",
+ "/mugfullwidth": "\u338D",
+ "/mugreek": "\u03BC",
+ "/mugsquare": "\u338D",
+ "/muhiragana": "\u3080",
+ "/mukatakana": "\u30E0",
+ "/mukatakanahalfwidth": "\uFF91",
+ "/mulfullwidth": "\u3395",
+ "/mulsquare": "\u3395",
+ "/multimap": "\u22B8",
+ "/multimapleft": "\u27DC",
+ "/multipleMusicalNotes": "\u1F3B6",
+ "/multiply": "\u00D7",
+ "/multiset": "\u228C",
+ "/multisetmultiplication": "\u228D",
+ "/multisetunion": "\u228E",
+ "/mum": "\uA773",
+ "/mumfullwidth": "\u339B",
+ "/mumsquare": "\u339B",
+ "/munach:hb": "\u05A3",
+ "/munahhebrew": "\u05A3",
+ "/munahlefthebrew": "\u05A3",
+ "/musfullwidth": "\u33B2",
+ "/mushroom": "\u1F344",
+ "/musicalKeyboard": "\u1F3B9",
+ "/musicalKeyboardJacks": "\u1F398",
+ "/musicalNote": "\u1F3B5",
+ "/musicalScore": "\u1F3BC",
+ "/musicalnote": "\u266A",
+ "/musicalnotedbl": "\u266B",
+ "/musicflat": "\u266D",
+ "/musicflatsign": "\u266D",
+ "/musicnatural": "\u266E",
+ "/musicsharp": "\u266F",
+ "/musicsharpsign": "\u266F",
+ "/mussquare": "\u33B2",
+ "/muvfullwidth": "\u33B6",
+ "/muvsquare": "\u33B6",
+ "/muwfullwidth": "\u33BC",
+ "/muwsquare": "\u33BC",
+ "/mvfullwidth": "\u33B7",
+ "/mvmegafullwidth": "\u33B9",
+ "/mvmegasquare": "\u33B9",
+ "/mvsquare": "\u33B7",
+ "/mwfullwidth": "\u33BD",
+ "/mwmegafullwidth": "\u33BF",
+ "/mwmegasquare": "\u33BF",
+ "/mwsquare": "\u33BD",
+ "/n": "\u006E",
+ "/n.inferior": "\u2099",
+ "/n.superior": "\u207F",
+ "/nabengali": "\u09A8",
+ "/nabla": "\u2207",
+ "/nacirclekatakana": "\u32E4",
+ "/nacute": "\u0144",
+ "/nadeva": "\u0928",
+ "/nafullwidth": "\u3381",
+ "/nagujarati": "\u0AA8",
+ "/nagurmukhi": "\u0A28",
+ "/nahiragana": "\u306A",
+ "/nailPolish": "\u1F485",
+ "/naira": "\u20A6",
+ "/nakatakana": "\u30CA",
+ "/nakatakanahalfwidth": "\uFF85",
+ "/nameBadge": "\u1F4DB",
+ "/nameideographiccircled": "\u3294",
+ "/nameideographicparen": "\u3234",
+ "/namurda": "\uA99F",
+ "/nand": "\u22BC",
+ "/nanosquare": "\u3328",
+ "/napostrophe": "\u0149",
+ "/narrownobreakspace": "\u202F",
+ "/nasquare": "\u3381",
+ "/nationalPark": "\u1F3DE",
+ "/nationaldigitshapes": "\u206E",
+ "/nbopomofo": "\u310B",
+ "/nbspace": "\u00A0",
+ "/ncaron": "\u0148",
+ "/ncedilla": "\u0146",
+ "/ncircle": "\u24DD",
+ "/ncircumflexbelow": "\u1E4B",
+ "/ncommaaccent": "\u0146",
+ "/ncurl": "\u0235",
+ "/ndescender": "\uA791",
+ "/ndot": "\u1E45",
+ "/ndotaccent": "\u1E45",
+ "/ndotbelow": "\u1E47",
+ "/necirclekatakana": "\u32E7",
+ "/necktie": "\u1F454",
+ "/negatedturnstiledblverticalbarright": "\u22AF",
+ "/nehiragana": "\u306D",
+ "/neirapproximatelynoractuallyequal": "\u2247",
+ "/neirasersetnorequalup": "\u2289",
+ "/neirasubsetnorequal": "\u2288",
+ "/neirgreaternorequal": "\u2271",
+ "/neirgreaternorequivalent": "\u2275",
+ "/neirgreaternorless": "\u2279",
+ "/neirlessnorequal": "\u2270",
+ "/neirlessnorequivalent": "\u2274",
+ "/neirlessnorgreater": "\u2278",
+ "/nekatakana": "\u30CD",
+ "/nekatakanahalfwidth": "\uFF88",
+ "/neptune": "\u2646",
+ "/neuter": "\u26B2",
+ "/neutralFace": "\u1F610",
+ "/newMoon": "\u1F311",
+ "/newMoonFace": "\u1F31A",
+ "/newsheqel": "\u20AA",
+ "/newsheqelsign": "\u20AA",
+ "/newspaper": "\u1F4F0",
+ "/newsquare": "\u1F195",
+ "/nextpage": "\u2398",
+ "/nffullwidth": "\u338B",
+ "/nfsquare": "\u338B",
+ "/ng.fina": "\uFBD4",
+ "/ng.init": "\uFBD5",
+ "/ng.isol": "\uFBD3",
+ "/ng.medi": "\uFBD6",
+ "/ngabengali": "\u0999",
+ "/ngadeva": "\u0919",
+ "/ngagujarati": "\u0A99",
+ "/ngagurmukhi": "\u0A19",
+ "/ngalelet": "\uA98A",
+ "/ngaleletraswadi": "\uA98B",
+ "/ngoeh": "\u06B1",
+ "/ngoeh.fina": "\uFB9B",
+ "/ngoeh.init": "\uFB9C",
+ "/ngoeh.isol": "\uFB9A",
+ "/ngoeh.medi": "\uFB9D",
+ "/ngonguthai": "\u0E07",
+ "/ngrave": "\u01F9",
+ "/ngsquare": "\u1F196",
+ "/nhiragana": "\u3093",
+ "/nhookleft": "\u0272",
+ "/nhookretroflex": "\u0273",
+ "/nicirclekatakana": "\u32E5",
+ "/nieunacirclekorean": "\u326F",
+ "/nieunaparenkorean": "\u320F",
+ "/nieuncieuckorean": "\u3135",
+ "/nieuncirclekorean": "\u3261",
+ "/nieunhieuhkorean": "\u3136",
+ "/nieunkorean": "\u3134",
+ "/nieunpansioskorean": "\u3168",
+ "/nieunparenkorean": "\u3201",
+ "/nieunsioskorean": "\u3167",
+ "/nieuntikeutkorean": "\u3166",
+ "/nightStars": "\u1F303",
+ "/nightideographiccircled": "\u32B0",
+ "/nihiragana": "\u306B",
+ "/nikatakana": "\u30CB",
+ "/nikatakanahalfwidth": "\uFF86",
+ "/nikhahitleftthai": "\uF899",
+ "/nikhahitthai": "\u0E4D",
+ "/nine": "\u0039",
+ "/nine.inferior": "\u2089",
+ "/nine.roman": "\u2168",
+ "/nine.romansmall": "\u2178",
+ "/nine.superior": "\u2079",
+ "/ninearabic": "\u0669",
+ "/ninebengali": "\u09EF",
+ "/ninecircle": "\u2468",
+ "/ninecircledbl": "\u24FD",
+ "/ninecircleinversesansserif": "\u2792",
+ "/ninecomma": "\u1F10A",
+ "/ninedeva": "\u096F",
+ "/ninefar": "\u06F9",
+ "/ninegujarati": "\u0AEF",
+ "/ninegurmukhi": "\u0A6F",
+ "/ninehackarabic": "\u0669",
+ "/ninehangzhou": "\u3029",
+ "/nineideographiccircled": "\u3288",
+ "/nineideographicparen": "\u3228",
+ "/nineinferior": "\u2089",
+ "/ninemonospace": "\uFF19",
+ "/nineoldstyle": "\uF739",
+ "/nineparen": "\u247C",
+ "/nineparenthesized": "\u247C",
+ "/nineperiod": "\u2490",
+ "/ninepersian": "\u06F9",
+ "/nineroman": "\u2178",
+ "/ninesuperior": "\u2079",
+ "/nineteencircle": "\u2472",
+ "/nineteencircleblack": "\u24F3",
+ "/nineteenparen": "\u2486",
+ "/nineteenparenthesized": "\u2486",
+ "/nineteenperiod": "\u249A",
+ "/ninethai": "\u0E59",
+ "/nj": "\u01CC",
+ "/njecyr": "\u045A",
+ "/njecyrillic": "\u045A",
+ "/njekomicyr": "\u050B",
+ "/nkatakana": "\u30F3",
+ "/nkatakanahalfwidth": "\uFF9D",
+ "/nlegrightlong": "\u019E",
+ "/nlinebelow": "\u1E49",
+ "/nlongrightleg": "\u019E",
+ "/nmbr:oneeighth": "\u215B",
+ "/nmbr:onefifth": "\u2155",
+ "/nmbr:onetenth": "\u2152",
+ "/nmfullwidth": "\u339A",
+ "/nmonospace": "\uFF4E",
+ "/nmsquare": "\u339A",
+ "/nnabengali": "\u09A3",
+ "/nnadeva": "\u0923",
+ "/nnagujarati": "\u0AA3",
+ "/nnagurmukhi": "\u0A23",
+ "/nnnadeva": "\u0929",
+ "/noBicycles": "\u1F6B3",
+ "/noEntrySign": "\u1F6AB",
+ "/noMobilePhones": "\u1F4F5",
+ "/noOneUnderEighteen": "\u1F51E",
+ "/noPedestrians": "\u1F6B7",
+ "/noPiracy": "\u1F572",
+ "/noSmoking": "\u1F6AD",
+ "/nobliquestroke": "\uA7A5",
+ "/nocirclekatakana": "\u32E8",
+ "/nodeascending": "\u260A",
+ "/nodedescending": "\u260B",
+ "/noentry": "\u26D4",
+ "/nohiragana": "\u306E",
+ "/nokatakana": "\u30CE",
+ "/nokatakanahalfwidth": "\uFF89",
+ "/nominaldigitshapes": "\u206F",
+ "/nonPotableWater": "\u1F6B1",
+ "/nonbreakinghyphen": "\u2011",
+ "/nonbreakingspace": "\u00A0",
+ "/nonenthai": "\u0E13",
+ "/nonuthai": "\u0E19",
+ "/noon": "\u0646",
+ "/noon.fina": "\uFEE6",
+ "/noon.init": "\uFEE7",
+ "/noon.init_alefmaksura.fina": "\uFC4F",
+ "/noon.init_hah.fina": "\uFC4C",
+ "/noon.init_hah.medi": "\uFCD3",
+ "/noon.init_hah.medi_meem.medi": "\uFD95",
+ "/noon.init_heh.medi": "\uFCD6",
+ "/noon.init_jeem.fina": "\uFC4B",
+ "/noon.init_jeem.medi": "\uFCD2",
+ "/noon.init_jeem.medi_hah.medi": "\uFDB8",
+ "/noon.init_jeem.medi_meem.medi": "\uFD98",
+ "/noon.init_khah.fina": "\uFC4D",
+ "/noon.init_khah.medi": "\uFCD4",
+ "/noon.init_meem.fina": "\uFC4E",
+ "/noon.init_meem.medi": "\uFCD5",
+ "/noon.init_yeh.fina": "\uFC50",
+ "/noon.isol": "\uFEE5",
+ "/noon.medi": "\uFEE8",
+ "/noon.medi_alefmaksura.fina": "\uFC8E",
+ "/noon.medi_hah.medi_alefmaksura.fina": "\uFD96",
+ "/noon.medi_hah.medi_yeh.fina": "\uFDB3",
+ "/noon.medi_heh.medi": "\uFCEF",
+ "/noon.medi_jeem.medi_alefmaksura.fina": "\uFD99",
+ "/noon.medi_jeem.medi_hah.fina": "\uFDBD",
+ "/noon.medi_jeem.medi_meem.fina": "\uFD97",
+ "/noon.medi_jeem.medi_yeh.fina": "\uFDC7",
+ "/noon.medi_meem.fina": "\uFC8C",
+ "/noon.medi_meem.medi": "\uFCEE",
+ "/noon.medi_meem.medi_alefmaksura.fina": "\uFD9B",
+ "/noon.medi_meem.medi_yeh.fina": "\uFD9A",
+ "/noon.medi_noon.fina": "\uFC8D",
+ "/noon.medi_reh.fina": "\uFC8A",
+ "/noon.medi_yeh.fina": "\uFC8F",
+ "/noon.medi_zain.fina": "\uFC8B",
+ "/noonSmallTah": "\u0768",
+ "/noonSmallV": "\u0769",
+ "/noonTwoDotsBelow": "\u0767",
+ "/noonabove": "\u06E8",
+ "/noonarabic": "\u0646",
+ "/noondotbelow": "\u06B9",
+ "/noonfinalarabic": "\uFEE6",
+ "/noonghunna": "\u06BA",
+ "/noonghunna.fina": "\uFB9F",
+ "/noonghunna.isol": "\uFB9E",
+ "/noonghunnaarabic": "\u06BA",
+ "/noonghunnafinalarabic": "\uFB9F",
+ "/noonhehinitialarabic": "\uFEE7",
+ "/nooninitialarabic": "\uFEE7",
+ "/noonjeeminitialarabic": "\uFCD2",
+ "/noonjeemisolatedarabic": "\uFC4B",
+ "/noonmedialarabic": "\uFEE8",
+ "/noonmeeminitialarabic": "\uFCD5",
+ "/noonmeemisolatedarabic": "\uFC4E",
+ "/noonnoonfinalarabic": "\uFC8D",
+ "/noonring": "\u06BC",
+ "/noonthreedotsabove": "\u06BD",
+ "/nor": "\u22BD",
+ "/nordicmark": "\u20BB",
+ "/normalfacrsemidirectproductleft": "\u22C9",
+ "/normalfacrsemidirectproductright": "\u22CA",
+ "/normalsubgroorequalup": "\u22B4",
+ "/normalsubgroup": "\u22B2",
+ "/northeastPointingAirplane": "\u1F6EA",
+ "/nose": "\u1F443",
+ "/notalmostequal": "\u2249",
+ "/notasersetup": "\u2285",
+ "/notasympticallyequal": "\u2244",
+ "/notcheckmark": "\u237B",
+ "/notchedLeftSemicircleThreeDots": "\u1F543",
+ "/notchedRightSemicircleThreeDots": "\u1F544",
+ "/notcontains": "\u220C",
+ "/note": "\u1F5C8",
+ "/notePad": "\u1F5CA",
+ "/notePage": "\u1F5C9",
+ "/notebook": "\u1F4D3",
+ "/notebookDecorativeCover": "\u1F4D4",
+ "/notelement": "\u2209",
+ "/notelementof": "\u2209",
+ "/notequal": "\u2260",
+ "/notequivalent": "\u226D",
+ "/notexistential": "\u2204",
+ "/notgreater": "\u226F",
+ "/notgreaternorequal": "\u2271",
+ "/notgreaternorless": "\u2279",
+ "/notidentical": "\u2262",
+ "/notless": "\u226E",
+ "/notlessnorequal": "\u2270",
+ "/notnormalsubgroorequalup": "\u22EC",
+ "/notnormalsubgroup": "\u22EA",
+ "/notparallel": "\u2226",
+ "/notprecedes": "\u2280",
+ "/notsignturned": "\u2319",
+ "/notsquareimageorequal": "\u22E2",
+ "/notsquareoriginalorequal": "\u22E3",
+ "/notsubset": "\u2284",
+ "/notsucceeds": "\u2281",
+ "/notsuperset": "\u2285",
+ "/nottilde": "\u2241",
+ "/nottosquare": "\u3329",
+ "/nottrue": "\u22AD",
+ "/novembertelegraph": "\u32CA",
+ "/nowarmenian": "\u0576",
+ "/nparen": "\u24A9",
+ "/nparenthesized": "\u24A9",
+ "/nretroflex": "\u0273",
+ "/nsfullwidth": "\u33B1",
+ "/nssquare": "\u33B1",
+ "/nsuperior": "\u207F",
+ "/ntilde": "\u00F1",
+ "/nu": "\u03BD",
+ "/nucirclekatakana": "\u32E6",
+ "/nuhiragana": "\u306C",
+ "/nukatakana": "\u30CC",
+ "/nukatakanahalfwidth": "\uFF87",
+ "/nuktabengali": "\u09BC",
+ "/nuktadeva": "\u093C",
+ "/nuktagujarati": "\u0ABC",
+ "/nuktagurmukhi": "\u0A3C",
+ "/num": "\uA774",
+ "/numbermarkabove": "\u0605",
+ "/numbersign": "\u0023",
+ "/numbersignmonospace": "\uFF03",
+ "/numbersignsmall": "\uFE5F",
+ "/numeralsign": "\u0374",
+ "/numeralsigngreek": "\u0374",
+ "/numeralsignlowergreek": "\u0375",
+ "/numero": "\u2116",
+ "/nun": "\u05E0",
+ "/nun:hb": "\u05E0",
+ "/nunHafukha:hb": "\u05C6",
+ "/nundagesh": "\uFB40",
+ "/nundageshhebrew": "\uFB40",
+ "/nunhebrew": "\u05E0",
+ "/nunwithdagesh:hb": "\uFB40",
+ "/nutAndBolt": "\u1F529",
+ "/nvfullwidth": "\u33B5",
+ "/nvsquare": "\u33B5",
+ "/nwfullwidth": "\u33BB",
+ "/nwsquare": "\u33BB",
+ "/nyabengali": "\u099E",
+ "/nyadeva": "\u091E",
+ "/nyagujarati": "\u0A9E",
+ "/nyagurmukhi": "\u0A1E",
+ "/nyamurda": "\uA998",
+ "/nyeh": "\u0683",
+ "/nyeh.fina": "\uFB77",
+ "/nyeh.init": "\uFB78",
+ "/nyeh.isol": "\uFB76",
+ "/nyeh.medi": "\uFB79",
+ "/o": "\u006F",
+ "/o.inferior": "\u2092",
+ "/oacute": "\u00F3",
+ "/oangthai": "\u0E2D",
+ "/obarcyr": "\u04E9",
+ "/obardieresiscyr": "\u04EB",
+ "/obarred": "\u0275",
+ "/obarredcyrillic": "\u04E9",
+ "/obarreddieresiscyrillic": "\u04EB",
+ "/obelosdotted": "\u2E13",
+ "/obengali": "\u0993",
+ "/obopomofo": "\u311B",
+ "/obreve": "\u014F",
+ "/observereye": "\u23FF",
+ "/ocandradeva": "\u0911",
+ "/ocandragujarati": "\u0A91",
+ "/ocandravowelsigndeva": "\u0949",
+ "/ocandravowelsigngujarati": "\u0AC9",
+ "/ocaron": "\u01D2",
+ "/ocircle": "\u24DE",
+ "/ocirclekatakana": "\u32D4",
+ "/ocircumflex": "\u00F4",
+ "/ocircumflexacute": "\u1ED1",
+ "/ocircumflexdotbelow": "\u1ED9",
+ "/ocircumflexgrave": "\u1ED3",
+ "/ocircumflexhoi": "\u1ED5",
+ "/ocircumflexhookabove": "\u1ED5",
+ "/ocircumflextilde": "\u1ED7",
+ "/ocr:bowtie": "\u2445",
+ "/ocr:dash": "\u2448",
+ "/octagonalSign": "\u1F6D1",
+ "/octobertelegraph": "\u32C9",
+ "/octopus": "\u1F419",
+ "/ocyr": "\u043E",
+ "/ocyrillic": "\u043E",
+ "/odblacute": "\u0151",
+ "/odblgrave": "\u020D",
+ "/oden": "\u1F362",
+ "/odeva": "\u0913",
+ "/odieresis": "\u00F6",
+ "/odieresiscyr": "\u04E7",
+ "/odieresiscyrillic": "\u04E7",
+ "/odieresismacron": "\u022B",
+ "/odot": "\u022F",
+ "/odotbelow": "\u1ECD",
+ "/odotmacron": "\u0231",
+ "/oe": "\u0153",
+ "/oe.fina": "\uFBDA",
+ "/oe.isol": "\uFBD9",
+ "/oekirghiz": "\u06C5",
+ "/oekirghiz.fina": "\uFBE1",
+ "/oekirghiz.isol": "\uFBE0",
+ "/oekorean": "\u315A",
+ "/officeBuilding": "\u1F3E2",
+ "/ogonek": "\u02DB",
+ "/ogonekcmb": "\u0328",
+ "/ograve": "\u00F2",
+ "/ogravedbl": "\u020D",
+ "/ogujarati": "\u0A93",
+ "/oharmenian": "\u0585",
+ "/ohiragana": "\u304A",
+ "/ohm": "\u2126",
+ "/ohminverted": "\u2127",
+ "/ohoi": "\u1ECF",
+ "/ohookabove": "\u1ECF",
+ "/ohorn": "\u01A1",
+ "/ohornacute": "\u1EDB",
+ "/ohorndotbelow": "\u1EE3",
+ "/ohorngrave": "\u1EDD",
+ "/ohornhoi": "\u1EDF",
+ "/ohornhookabove": "\u1EDF",
+ "/ohorntilde": "\u1EE1",
+ "/ohungarumlaut": "\u0151",
+ "/ohuparen": "\u321E",
+ "/oi": "\u01A3",
+ "/oilDrum": "\u1F6E2",
+ "/oinvertedbreve": "\u020F",
+ "/ojeonparen": "\u321D",
+ "/okHandSign": "\u1F44C",
+ "/okatakana": "\u30AA",
+ "/okatakanahalfwidth": "\uFF75",
+ "/okorean": "\u3157",
+ "/oksquare": "\u1F197",
+ "/oldKey": "\u1F5DD",
+ "/oldPersonalComputer": "\u1F5B3",
+ "/olderMan": "\u1F474",
+ "/olderWoman": "\u1F475",
+ "/ole:hb": "\u05AB",
+ "/olehebrew": "\u05AB",
+ "/oloop": "\uA74D",
+ "/olowringinside": "\u2C7A",
+ "/omacron": "\u014D",
+ "/omacronacute": "\u1E53",
+ "/omacrongrave": "\u1E51",
+ "/omdeva": "\u0950",
+ "/omega": "\u03C9",
+ "/omega1": "\u03D6",
+ "/omegaacute": "\u1F7D",
+ "/omegaacuteiotasub": "\u1FF4",
+ "/omegaasper": "\u1F61",
+ "/omegaasperacute": "\u1F65",
+ "/omegaasperacuteiotasub": "\u1FA5",
+ "/omegaaspergrave": "\u1F63",
+ "/omegaaspergraveiotasub": "\u1FA3",
+ "/omegaasperiotasub": "\u1FA1",
+ "/omegaaspertilde": "\u1F67",
+ "/omegaaspertildeiotasub": "\u1FA7",
+ "/omegaclosed": "\u0277",
+ "/omegacyr": "\u0461",
+ "/omegacyrillic": "\u0461",
+ "/omegafunc": "\u2375",
+ "/omegagrave": "\u1F7C",
+ "/omegagraveiotasub": "\u1FF2",
+ "/omegaiotasub": "\u1FF3",
+ "/omegalatinclosed": "\u0277",
+ "/omegalenis": "\u1F60",
+ "/omegalenisacute": "\u1F64",
+ "/omegalenisacuteiotasub": "\u1FA4",
+ "/omegalenisgrave": "\u1F62",
+ "/omegalenisgraveiotasub": "\u1FA2",
+ "/omegalenisiotasub": "\u1FA0",
+ "/omegalenistilde": "\u1F66",
+ "/omegalenistildeiotasub": "\u1FA6",
+ "/omegaroundcyr": "\u047B",
+ "/omegaroundcyrillic": "\u047B",
+ "/omegatilde": "\u1FF6",
+ "/omegatildeiotasub": "\u1FF7",
+ "/omegatitlocyr": "\u047D",
+ "/omegatitlocyrillic": "\u047D",
+ "/omegatonos": "\u03CE",
+ "/omegaunderlinefunc": "\u2379",
+ "/omgujarati": "\u0AD0",
+ "/omicron": "\u03BF",
+ "/omicronacute": "\u1F79",
+ "/omicronasper": "\u1F41",
+ "/omicronasperacute": "\u1F45",
+ "/omicronaspergrave": "\u1F43",
+ "/omicrongrave": "\u1F78",
+ "/omicronlenis": "\u1F40",
+ "/omicronlenisacute": "\u1F44",
+ "/omicronlenisgrave": "\u1F42",
+ "/omicrontonos": "\u03CC",
+ "/omonospace": "\uFF4F",
+ "/onExclamationMarkLeftRightArrowAbove": "\u1F51B",
+ "/oncomingAutomobile": "\u1F698",
+ "/oncomingBus": "\u1F68D",
+ "/oncomingFireEngine": "\u1F6F1",
+ "/oncomingPoliceCar": "\u1F694",
+ "/oncomingTaxi": "\u1F696",
+ "/one": "\u0031",
+ "/one.inferior": "\u2081",
+ "/one.roman": "\u2160",
+ "/one.romansmall": "\u2170",
+ "/oneButtonMouse": "\u1F5AF",
+ "/onearabic": "\u0661",
+ "/onebengali": "\u09E7",
+ "/onecircle": "\u2460",
+ "/onecircledbl": "\u24F5",
+ "/onecircleinversesansserif": "\u278A",
+ "/onecomma": "\u1F102",
+ "/onedeva": "\u0967",
+ "/onedotenleader": "\u2024",
+ "/onedotovertwodots": "\u2E2B",
+ "/oneeighth": "\u215B",
+ "/onefar": "\u06F1",
+ "/onefitted": "\uF6DC",
+ "/onefraction": "\u215F",
+ "/onegujarati": "\u0AE7",
+ "/onegurmukhi": "\u0A67",
+ "/onehackarabic": "\u0661",
+ "/onehalf": "\u00BD",
+ "/onehangzhou": "\u3021",
+ "/onehundred.roman": "\u216D",
+ "/onehundred.romansmall": "\u217D",
+ "/onehundredthousand.roman": "\u2188",
+ "/onehundredtwentypsquare": "\u1F1A4",
+ "/oneideographiccircled": "\u3280",
+ "/oneideographicparen": "\u3220",
+ "/oneinferior": "\u2081",
+ "/onemonospace": "\uFF11",
+ "/oneninth": "\u2151",
+ "/onenumeratorbengali": "\u09F4",
+ "/oneoldstyle": "\uF731",
+ "/oneparen": "\u2474",
+ "/oneparenthesized": "\u2474",
+ "/oneperiod": "\u2488",
+ "/onepersian": "\u06F1",
+ "/onequarter": "\u00BC",
+ "/oneroman": "\u2170",
+ "/oneseventh": "\u2150",
+ "/onesixth": "\u2159",
+ "/onesuperior": "\u00B9",
+ "/onethai": "\u0E51",
+ "/onethird": "\u2153",
+ "/onethousand.roman": "\u216F",
+ "/onethousand.romansmall": "\u217F",
+ "/onethousandcd.roman": "\u2180",
+ "/onsusquare": "\u3309",
+ "/oo": "\uA74F",
+ "/oogonek": "\u01EB",
+ "/oogonekmacron": "\u01ED",
+ "/oogurmukhi": "\u0A13",
+ "/oomatragurmukhi": "\u0A4B",
+ "/oomusquare": "\u330A",
+ "/oopen": "\u0254",
+ "/oparen": "\u24AA",
+ "/oparenthesized": "\u24AA",
+ "/openBook": "\u1F4D6",
+ "/openFileFolder": "\u1F4C2",
+ "/openFolder": "\u1F5C1",
+ "/openHandsSign": "\u1F450",
+ "/openLock": "\u1F513",
+ "/openMailboxLoweredFlag": "\u1F4ED",
+ "/openMailboxRaisedFlag": "\u1F4EC",
+ "/openbullet": "\u25E6",
+ "/openheadarrowleft": "\u21FD",
+ "/openheadarrowleftright": "\u21FF",
+ "/openheadarrowright": "\u21FE",
+ "/opensubset": "\u27C3",
+ "/opensuperset": "\u27C4",
+ "/ophiuchus": "\u26CE",
+ "/opposition": "\u260D",
+ "/opticalDisc": "\u1F4BF",
+ "/opticalDiscIcon": "\u1F5B8",
+ "/option": "\u2325",
+ "/orangeBook": "\u1F4D9",
+ "/ordfeminine": "\u00AA",
+ "/ordmasculine": "\u00BA",
+ "/ordotinside": "\u27C7",
+ "/original": "\u22B6",
+ "/ornateleftparenthesis": "\uFD3E",
+ "/ornaterightparenthesis": "\uFD3F",
+ "/orthodoxcross": "\u2626",
+ "/orthogonal": "\u221F",
+ "/orya:a": "\u0B05",
+ "/orya:aa": "\u0B06",
+ "/orya:aasign": "\u0B3E",
+ "/orya:ai": "\u0B10",
+ "/orya:ailengthmark": "\u0B56",
+ "/orya:aisign": "\u0B48",
+ "/orya:anusvara": "\u0B02",
+ "/orya:au": "\u0B14",
+ "/orya:aulengthmark": "\u0B57",
+ "/orya:ausign": "\u0B4C",
+ "/orya:avagraha": "\u0B3D",
+ "/orya:ba": "\u0B2C",
+ "/orya:bha": "\u0B2D",
+ "/orya:ca": "\u0B1A",
+ "/orya:candrabindu": "\u0B01",
+ "/orya:cha": "\u0B1B",
+ "/orya:da": "\u0B26",
+ "/orya:dda": "\u0B21",
+ "/orya:ddha": "\u0B22",
+ "/orya:dha": "\u0B27",
+ "/orya:e": "\u0B0F",
+ "/orya:eight": "\u0B6E",
+ "/orya:esign": "\u0B47",
+ "/orya:five": "\u0B6B",
+ "/orya:four": "\u0B6A",
+ "/orya:fractiononeeighth": "\u0B76",
+ "/orya:fractiononehalf": "\u0B73",
+ "/orya:fractiononequarter": "\u0B72",
+ "/orya:fractiononesixteenth": "\u0B75",
+ "/orya:fractionthreequarters": "\u0B74",
+ "/orya:fractionthreesixteenths": "\u0B77",
+ "/orya:ga": "\u0B17",
+ "/orya:gha": "\u0B18",
+ "/orya:ha": "\u0B39",
+ "/orya:i": "\u0B07",
+ "/orya:ii": "\u0B08",
+ "/orya:iisign": "\u0B40",
+ "/orya:isign": "\u0B3F",
+ "/orya:isshar": "\u0B70",
+ "/orya:ja": "\u0B1C",
+ "/orya:jha": "\u0B1D",
+ "/orya:ka": "\u0B15",
+ "/orya:kha": "\u0B16",
+ "/orya:la": "\u0B32",
+ "/orya:lla": "\u0B33",
+ "/orya:llvocal": "\u0B61",
+ "/orya:llvocalsign": "\u0B63",
+ "/orya:lvocal": "\u0B0C",
+ "/orya:lvocalsign": "\u0B62",
+ "/orya:ma": "\u0B2E",
+ "/orya:na": "\u0B28",
+ "/orya:nga": "\u0B19",
+ "/orya:nine": "\u0B6F",
+ "/orya:nna": "\u0B23",
+ "/orya:nukta": "\u0B3C",
+ "/orya:nya": "\u0B1E",
+ "/orya:o": "\u0B13",
+ "/orya:one": "\u0B67",
+ "/orya:osign": "\u0B4B",
+ "/orya:pa": "\u0B2A",
+ "/orya:pha": "\u0B2B",
+ "/orya:ra": "\u0B30",
+ "/orya:rha": "\u0B5D",
+ "/orya:rra": "\u0B5C",
+ "/orya:rrvocal": "\u0B60",
+ "/orya:rrvocalsign": "\u0B44",
+ "/orya:rvocal": "\u0B0B",
+ "/orya:rvocalsign": "\u0B43",
+ "/orya:sa": "\u0B38",
+ "/orya:seven": "\u0B6D",
+ "/orya:sha": "\u0B36",
+ "/orya:six": "\u0B6C",
+ "/orya:ssa": "\u0B37",
+ "/orya:ta": "\u0B24",
+ "/orya:tha": "\u0B25",
+ "/orya:three": "\u0B69",
+ "/orya:tta": "\u0B1F",
+ "/orya:ttha": "\u0B20",
+ "/orya:two": "\u0B68",
+ "/orya:u": "\u0B09",
+ "/orya:usign": "\u0B41",
+ "/orya:uu": "\u0B0A",
+ "/orya:uusign": "\u0B42",
+ "/orya:va": "\u0B35",
+ "/orya:virama": "\u0B4D",
+ "/orya:visarga": "\u0B03",
+ "/orya:wa": "\u0B71",
+ "/orya:ya": "\u0B2F",
+ "/orya:yya": "\u0B5F",
+ "/orya:zero": "\u0B66",
+ "/oscript": "\u2134",
+ "/oshortdeva": "\u0912",
+ "/oshortvowelsigndeva": "\u094A",
+ "/oslash": "\u00F8",
+ "/oslashacute": "\u01FF",
+ "/osmallhiragana": "\u3049",
+ "/osmallkatakana": "\u30A9",
+ "/osmallkatakanahalfwidth": "\uFF6B",
+ "/ostroke": "\uA74B",
+ "/ostrokeacute": "\u01FF",
+ "/osuperior": "\uF6F0",
+ "/otcyr": "\u047F",
+ "/otcyrillic": "\u047F",
+ "/otilde": "\u00F5",
+ "/otildeacute": "\u1E4D",
+ "/otildedieresis": "\u1E4F",
+ "/otildemacron": "\u022D",
+ "/ou": "\u0223",
+ "/oubopomofo": "\u3121",
+ "/ounce": "\u2125",
+ "/outboxTray": "\u1F4E4",
+ "/outerjoinfull": "\u27D7",
+ "/outerjoinleft": "\u27D5",
+ "/outerjoinright": "\u27D6",
+ "/outputpassiveup": "\u2392",
+ "/overlap": "\u1F5D7",
+ "/overline": "\u203E",
+ "/overlinecenterline": "\uFE4A",
+ "/overlinecmb": "\u0305",
+ "/overlinedashed": "\uFE49",
+ "/overlinedblwavy": "\uFE4C",
+ "/overlinewavy": "\uFE4B",
+ "/overscore": "\u00AF",
+ "/ovfullwidth": "\u3375",
+ "/ovowelsignbengali": "\u09CB",
+ "/ovowelsigndeva": "\u094B",
+ "/ovowelsigngujarati": "\u0ACB",
+ "/ox": "\u1F402",
+ "/p": "\u0070",
+ "/p.inferior": "\u209A",
+ "/paampsfullwidth": "\u3380",
+ "/paampssquare": "\u3380",
+ "/paasentosquare": "\u332B",
+ "/paatusquare": "\u332C",
+ "/pabengali": "\u09AA",
+ "/pacerek": "\uA989",
+ "/package": "\u1F4E6",
+ "/pacute": "\u1E55",
+ "/padeva": "\u092A",
+ "/pafullwidth": "\u33A9",
+ "/page": "\u1F5CF",
+ "/pageCircledText": "\u1F5DF",
+ "/pageCurl": "\u1F4C3",
+ "/pageFacingUp": "\u1F4C4",
+ "/pagedown": "\u21DF",
+ "/pager": "\u1F4DF",
+ "/pages": "\u1F5D0",
+ "/pageup": "\u21DE",
+ "/pagoda": "\u1F6D4",
+ "/pagujarati": "\u0AAA",
+ "/pagurmukhi": "\u0A2A",
+ "/pahiragana": "\u3071",
+ "/paiyannoithai": "\u0E2F",
+ "/pakatakana": "\u30D1",
+ "/palatalizationcyrilliccmb": "\u0484",
+ "/palatcmbcyr": "\u0484",
+ "/pallas": "\u26B4",
+ "/palmTree": "\u1F334",
+ "/palmbranch": "\u2E19",
+ "/palochkacyr": "\u04CF",
+ "/palochkacyrillic": "\u04C0",
+ "/pamurda": "\uA9A6",
+ "/pandaFace": "\u1F43C",
+ "/pangkatpada": "\uA9C7",
+ "/pangkon": "\uA9C0",
+ "/pangrangkep": "\uA9CF",
+ "/pansioskorean": "\u317F",
+ "/panyangga": "\uA980",
+ "/paperclip": "\u1F4CE",
+ "/paragraph": "\u00B6",
+ "/paragraphos": "\u2E0F",
+ "/paragraphosforked": "\u2E10",
+ "/paragraphosforkedreversed": "\u2E11",
+ "/paragraphseparator": "\u2029",
+ "/parallel": "\u2225",
+ "/parallelogramblack": "\u25B0",
+ "/parallelogramwhite": "\u25B1",
+ "/parenbottom": "\u23DD",
+ "/parendblleft": "\u2E28",
+ "/parendblright": "\u2E29",
+ "/parenextensionleft": "\u239C",
+ "/parenextensionright": "\u239F",
+ "/parenflatleft": "\u27EE",
+ "/parenflatright": "\u27EF",
+ "/parenhookupleft": "\u239B",
+ "/parenhookupright": "\u239E",
+ "/parenleft": "\u0028",
+ "/parenleft.inferior": "\u208D",
+ "/parenleft.superior": "\u207D",
+ "/parenleftaltonearabic": "\uFD3E",
+ "/parenleftbt": "\uF8ED",
+ "/parenleftex": "\uF8EC",
+ "/parenleftinferior": "\u208D",
+ "/parenleftmonospace": "\uFF08",
+ "/parenleftsmall": "\uFE59",
+ "/parenleftsuperior": "\u207D",
+ "/parenlefttp": "\uF8EB",
+ "/parenleftvertical": "\uFE35",
+ "/parenlowerhookleft": "\u239D",
+ "/parenlowerhookright": "\u23A0",
+ "/parenright": "\u0029",
+ "/parenright.inferior": "\u208E",
+ "/parenright.superior": "\u207E",
+ "/parenrightaltonearabic": "\uFD3F",
+ "/parenrightbt": "\uF8F8",
+ "/parenrightex": "\uF8F7",
+ "/parenrightinferior": "\u208E",
+ "/parenrightmonospace": "\uFF09",
+ "/parenrightsmall": "\uFE5A",
+ "/parenrightsuperior": "\u207E",
+ "/parenrighttp": "\uF8F6",
+ "/parenrightvertical": "\uFE36",
+ "/parentop": "\u23DC",
+ "/partalternationmark": "\u303D",
+ "/partialdiff": "\u2202",
+ "/partnership": "\u3250",
+ "/partyPopper": "\u1F389",
+ "/paseq:hb": "\u05C0",
+ "/paseqhebrew": "\u05C0",
+ "/pashta:hb": "\u0599",
+ "/pashtahebrew": "\u0599",
+ "/pasquare": "\u33A9",
+ "/passengerShip": "\u1F6F3",
+ "/passivedown": "\u2391",
+ "/passportControl": "\u1F6C2",
+ "/patah": "\u05B7",
+ "/patah11": "\u05B7",
+ "/patah1d": "\u05B7",
+ "/patah2a": "\u05B7",
+ "/patah:hb": "\u05B7",
+ "/patahhebrew": "\u05B7",
+ "/patahnarrowhebrew": "\u05B7",
+ "/patahquarterhebrew": "\u05B7",
+ "/patahwidehebrew": "\u05B7",
+ "/pawPrints": "\u1F43E",
+ "/pawnblack": "\u265F",
+ "/pawnwhite": "\u2659",
+ "/pazer:hb": "\u05A1",
+ "/pazerhebrew": "\u05A1",
+ "/pbopomofo": "\u3106",
+ "/pcfullwidth": "\u3376",
+ "/pcircle": "\u24DF",
+ "/pdot": "\u1E57",
+ "/pdotaccent": "\u1E57",
+ "/pe": "\u05E4",
+ "/pe:hb": "\u05E4",
+ "/peace": "\u262E",
+ "/peach": "\u1F351",
+ "/pear": "\u1F350",
+ "/pecyr": "\u043F",
+ "/pecyrillic": "\u043F",
+ "/pedagesh": "\uFB44",
+ "/pedageshhebrew": "\uFB44",
+ "/pedestrian": "\u1F6B6",
+ "/peezisquare": "\u333B",
+ "/pefinaldageshhebrew": "\uFB43",
+ "/peh.fina": "\uFB57",
+ "/peh.init": "\uFB58",
+ "/peh.isol": "\uFB56",
+ "/peh.medi": "\uFB59",
+ "/peharabic": "\u067E",
+ "/peharmenian": "\u057A",
+ "/pehebrew": "\u05E4",
+ "/peheh": "\u06A6",
+ "/peheh.fina": "\uFB6F",
+ "/peheh.init": "\uFB70",
+ "/peheh.isol": "\uFB6E",
+ "/peheh.medi": "\uFB71",
+ "/pehfinalarabic": "\uFB57",
+ "/pehinitialarabic": "\uFB58",
+ "/pehiragana": "\u307A",
+ "/pehmedialarabic": "\uFB59",
+ "/pehookcyr": "\u04A7",
+ "/pekatakana": "\u30DA",
+ "/pemiddlehookcyrillic": "\u04A7",
+ "/penOverStampedEnvelope": "\u1F586",
+ "/pengkalconsonant": "\uA9BE",
+ "/penguin": "\u1F427",
+ "/penihisquare": "\u3338",
+ "/pensiveFace": "\u1F614",
+ "/pensusquare": "\u333A",
+ "/pentagram": "\u26E4",
+ "/pentasememetrical": "\u23D9",
+ "/pepetvowel": "\uA9BC",
+ "/per": "\u214C",
+ "/perafehebrew": "\uFB4E",
+ "/percent": "\u0025",
+ "/percentarabic": "\u066A",
+ "/percentmonospace": "\uFF05",
+ "/percentsmall": "\uFE6A",
+ "/percussivebidental": "\u02AD",
+ "/percussivebilabial": "\u02AC",
+ "/performingArts": "\u1F3AD",
+ "/period": "\u002E",
+ "/periodarmenian": "\u0589",
+ "/periodcentered": "\u00B7",
+ "/periodhalfwidth": "\uFF61",
+ "/periodinferior": "\uF6E7",
+ "/periodmonospace": "\uFF0E",
+ "/periodsmall": "\uFE52",
+ "/periodsuperior": "\uF6E8",
+ "/periodurdu": "\u06D4",
+ "/perispomenigreekcmb": "\u0342",
+ "/permanentpaper": "\u267E",
+ "/permille": "\u0609",
+ "/perpendicular": "\u22A5",
+ "/perseveringFace": "\u1F623",
+ "/personBlondHair": "\u1F471",
+ "/personBowingDeeply": "\u1F647",
+ "/personFrowning": "\u1F64D",
+ "/personRaisingBothHandsInCelebration": "\u1F64C",
+ "/personWithFoldedHands": "\u1F64F",
+ "/personWithPoutingFace": "\u1F64E",
+ "/personalComputer": "\u1F4BB",
+ "/personball": "\u26F9",
+ "/perspective": "\u2306",
+ "/pertenthousandsign": "\u2031",
+ "/perthousand": "\u2030",
+ "/peseta": "\u20A7",
+ "/peso": "\u20B1",
+ "/pesosquare": "\u3337",
+ "/petailcyr": "\u0525",
+ "/pewithdagesh:hb": "\uFB44",
+ "/pewithrafe:hb": "\uFB4E",
+ "/pffullwidth": "\u338A",
+ "/pflourish": "\uA753",
+ "/pfsquare": "\u338A",
+ "/phabengali": "\u09AB",
+ "/phadeva": "\u092B",
+ "/phagujarati": "\u0AAB",
+ "/phagurmukhi": "\u0A2B",
+ "/pharyngealvoicedfricative": "\u0295",
+ "/phfullwidth": "\u33D7",
+ "/phi": "\u03C6",
+ "/phi.math": "\u03D5",
+ "/phi1": "\u03D5",
+ "/phieuphacirclekorean": "\u327A",
+ "/phieuphaparenkorean": "\u321A",
+ "/phieuphcirclekorean": "\u326C",
+ "/phieuphkorean": "\u314D",
+ "/phieuphparenkorean": "\u320C",
+ "/philatin": "\u0278",
+ "/phinthuthai": "\u0E3A",
+ "/phisymbolgreek": "\u03D5",
+ "/phitailless": "\u2C77",
+ "/phon:AEsmall": "\u1D01",
+ "/phon:Aemod": "\u1D2D",
+ "/phon:Amod": "\u1D2C",
+ "/phon:Asmall": "\u1D00",
+ "/phon:Bbarmod": "\u1D2F",
+ "/phon:Bbarsmall": "\u1D03",
+ "/phon:Bmod": "\u1D2E",
+ "/phon:Csmall": "\u1D04",
+ "/phon:Dmod": "\u1D30",
+ "/phon:Dsmall": "\u1D05",
+ "/phon:ENcyrmod": "\u1D78",
+ "/phon:Elsmallcyr": "\u1D2B",
+ "/phon:Emod": "\u1D31",
+ "/phon:Ereversedmod": "\u1D32",
+ "/phon:Esmall": "\u1D07",
+ "/phon:Ethsmall": "\u1D06",
+ "/phon:Ezhsmall": "\u1D23",
+ "/phon:Gmod": "\u1D33",
+ "/phon:Hmod": "\u1D34",
+ "/phon:Imod": "\u1D35",
+ "/phon:Ismallmod": "\u1DA6",
+ "/phon:Ismallstroke": "\u1D7B",
+ "/phon:Istrokesmallmod": "\u1DA7",
+ "/phon:Jmod": "\u1D36",
+ "/phon:Jsmall": "\u1D0A",
+ "/phon:Kmod": "\u1D37",
+ "/phon:Ksmall": "\u1D0B",
+ "/phon:Lmod": "\u1D38",
+ "/phon:Lsmallmod": "\u1DAB",
+ "/phon:Lsmallstroke": "\u1D0C",
+ "/phon:Mmod": "\u1D39",
+ "/phon:Msmall": "\u1D0D",
+ "/phon:Nmod": "\u1D3A",
+ "/phon:Nreversedmod": "\u1D3B",
+ "/phon:Nsmallmod": "\u1DB0",
+ "/phon:Nsmallreversed": "\u1D0E",
+ "/phon:OUsmall": "\u1D15",
+ "/phon:Omod": "\u1D3C",
+ "/phon:Oopensmall": "\u1D10",
+ "/phon:Osmall": "\u1D0F",
+ "/phon:Oumod": "\u1D3D",
+ "/phon:Pmod": "\u1D3E",
+ "/phon:Psmall": "\u1D18",
+ "/phon:Rmod": "\u1D3F",
+ "/phon:Rsmallreversed": "\u1D19",
+ "/phon:Rsmallturned": "\u1D1A",
+ "/phon:Tmod": "\u1D40",
+ "/phon:Tsmall": "\u1D1B",
+ "/phon:Umod": "\u1D41",
+ "/phon:Usmall": "\u1D1C",
+ "/phon:Usmallmod": "\u1DB8",
+ "/phon:Usmallstroke": "\u1D7E",
+ "/phon:Vsmall": "\u1D20",
+ "/phon:Wmod": "\u1D42",
+ "/phon:Wsmall": "\u1D21",
+ "/phon:Zsmall": "\u1D22",
+ "/phon:aeturned": "\u1D02",
+ "/phon:aeturnedmod": "\u1D46",
+ "/phon:ain": "\u1D25",
+ "/phon:ainmod": "\u1D5C",
+ "/phon:alphamod": "\u1D45",
+ "/phon:alpharetroflexhook": "\u1D90",
+ "/phon:alphaturnedmod": "\u1D9B",
+ "/phon:amod": "\u1D43",
+ "/phon:aretroflexhook": "\u1D8F",
+ "/phon:aturnedmod": "\u1D44",
+ "/phon:betamod": "\u1D5D",
+ "/phon:bmiddletilde": "\u1D6C",
+ "/phon:bmod": "\u1D47",
+ "/phon:bpalatalhook": "\u1D80",
+ "/phon:ccurlmod": "\u1D9D",
+ "/phon:chimod": "\u1D61",
+ "/phon:cmod": "\u1D9C",
+ "/phon:deltamod": "\u1D5F",
+ "/phon:dhooktail": "\u1D91",
+ "/phon:dmiddletilde": "\u1D6D",
+ "/phon:dmod": "\u1D48",
+ "/phon:dotlessjstrokemod": "\u1DA1",
+ "/phon:dpalatalhook": "\u1D81",
+ "/phon:emod": "\u1D49",
+ "/phon:engmod": "\u1D51",
+ "/phon:eopenmod": "\u1D4B",
+ "/phon:eopenretroflexhook": "\u1D93",
+ "/phon:eopenreversedmod": "\u1D9F",
+ "/phon:eopenreversedretroflexhook": "\u1D94",
+ "/phon:eopenturned": "\u1D08",
+ "/phon:eopenturnedmod": "\u1D4C",
+ "/phon:eretroflexhook": "\u1D92",
+ "/phon:eshmod": "\u1DB4",
+ "/phon:eshpalatalhook": "\u1D8B",
+ "/phon:eshretroflexhook": "\u1D98",
+ "/phon:ethmod": "\u1D9E",
+ "/phon:ezhmod": "\u1DBE",
+ "/phon:ezhretroflexhook": "\u1D9A",
+ "/phon:fmiddletilde": "\u1D6E",
+ "/phon:fmod": "\u1DA0",
+ "/phon:fpalatalhook": "\u1D82",
+ "/phon:ginsular": "\u1D79",
+ "/phon:gmod": "\u1D4D",
+ "/phon:gpalatalhook": "\u1D83",
+ "/phon:gr:Gammasmall": "\u1D26",
+ "/phon:gr:Lambdasmall": "\u1D27",
+ "/phon:gr:Pismall": "\u1D28",
+ "/phon:gr:Psismall": "\u1D2A",
+ "/phon:gr:RsmallHO": "\u1D29",
+ "/phon:gr:betasubscript": "\u1D66",
+ "/phon:gr:chisubscript": "\u1D6A",
+ "/phon:gr:gammamod": "\u1D5E",
+ "/phon:gr:gammasubscript": "\u1D67",
+ "/phon:gr:phimod": "\u1D60",
+ "/phon:gr:phisubscript": "\u1D69",
+ "/phon:gr:rhosubscript": "\u1D68",
+ "/phon:gscriptmod": "\u1DA2",
+ "/phon:gturned": "\u1D77",
+ "/phon:hturnedmod": "\u1DA3",
+ "/phon:iotamod": "\u1DA5",
+ "/phon:iotastroke": "\u1D7C",
+ "/phon:iretroflexhook": "\u1D96",
+ "/phon:istrokemod": "\u1DA4",
+ "/phon:isubscript": "\u1D62",
+ "/phon:iturned": "\u1D09",
+ "/phon:iturnedmod": "\u1D4E",
+ "/phon:jcrossedtailmod": "\u1DA8",
+ "/phon:kmod": "\u1D4F",
+ "/phon:kpalatalhook": "\u1D84",
+ "/phon:lpalatalhook": "\u1D85",
+ "/phon:lpalatalhookmod": "\u1DAA",
+ "/phon:lretroflexhookmod": "\u1DA9",
+ "/phon:mhookmod": "\u1DAC",
+ "/phon:mlonglegturnedmod": "\u1DAD",
+ "/phon:mmiddletilde": "\u1D6F",
+ "/phon:mmod": "\u1D50",
+ "/phon:mpalatalhook": "\u1D86",
+ "/phon:mturnedmod": "\u1D5A",
+ "/phon:mturnedsideways": "\u1D1F",
+ "/phon:nlefthookmod": "\u1DAE",
+ "/phon:nmiddletilde": "\u1D70",
+ "/phon:npalatalhook": "\u1D87",
+ "/phon:nretroflexhookmod": "\u1DAF",
+ "/phon:obarmod": "\u1DB1",
+ "/phon:obottomhalf": "\u1D17",
+ "/phon:obottomhalfmod": "\u1D55",
+ "/phon:oeturned": "\u1D14",
+ "/phon:omod": "\u1D52",
+ "/phon:oopenmod": "\u1D53",
+ "/phon:oopenretroflexhook": "\u1D97",
+ "/phon:oopensideways": "\u1D12",
+ "/phon:osideways": "\u1D11",
+ "/phon:ostrokesideways": "\u1D13",
+ "/phon:otophalf": "\u1D16",
+ "/phon:otophalfmod": "\u1D54",
+ "/phon:phimod": "\u1DB2",
+ "/phon:pmiddletilde": "\u1D71",
+ "/phon:pmod": "\u1D56",
+ "/phon:ppalatalhook": "\u1D88",
+ "/phon:pstroke": "\u1D7D",
+ "/phon:rfishmiddletilde": "\u1D73",
+ "/phon:rmiddletilde": "\u1D72",
+ "/phon:rpalatalhook": "\u1D89",
+ "/phon:rsubscript": "\u1D63",
+ "/phon:schwamod": "\u1D4A",
+ "/phon:schwaretroflexhook": "\u1D95",
+ "/phon:shookmod": "\u1DB3",
+ "/phon:smiddletilde": "\u1D74",
+ "/phon:spalatalhook": "\u1D8A",
+ "/phon:spirantvoicedlaryngeal": "\u1D24",
+ "/phon:thetamod": "\u1DBF",
+ "/phon:thstrike": "\u1D7A",
+ "/phon:tmiddletilde": "\u1D75",
+ "/phon:tmod": "\u1D57",
+ "/phon:tpalatalhookmod": "\u1DB5",
+ "/phon:ubarmod": "\u1DB6",
+ "/phon:ue": "\u1D6B",
+ "/phon:umod": "\u1D58",
+ "/phon:upsilonmod": "\u1DB7",
+ "/phon:upsilonstroke": "\u1D7F",
+ "/phon:uretroflexhook": "\u1D99",
+ "/phon:usideways": "\u1D1D",
+ "/phon:usidewaysdieresised": "\u1D1E",
+ "/phon:usidewaysmod": "\u1D59",
+ "/phon:usubscript": "\u1D64",
+ "/phon:vhookmod": "\u1DB9",
+ "/phon:vmod": "\u1D5B",
+ "/phon:vpalatalhook": "\u1D8C",
+ "/phon:vsubscript": "\u1D65",
+ "/phon:vturnedmod": "\u1DBA",
+ "/phon:xpalatalhook": "\u1D8D",
+ "/phon:zcurlmod": "\u1DBD",
+ "/phon:zmiddletilde": "\u1D76",
+ "/phon:zmod": "\u1DBB",
+ "/phon:zpalatalhook": "\u1D8E",
+ "/phon:zretroflexhookmod": "\u1DBC",
+ "/phook": "\u01A5",
+ "/phophanthai": "\u0E1E",
+ "/phophungthai": "\u0E1C",
+ "/phosamphaothai": "\u0E20",
+ "/pi": "\u03C0",
+ "/pi.math": "\u03D6",
+ "/piasutorusquare": "\u332E",
+ "/pick": "\u26CF",
+ "/pidblstruck": "\u213C",
+ "/pieupacirclekorean": "\u3273",
+ "/pieupaparenkorean": "\u3213",
+ "/pieupcieuckorean": "\u3176",
+ "/pieupcirclekorean": "\u3265",
+ "/pieupkiyeokkorean": "\u3172",
+ "/pieupkorean": "\u3142",
+ "/pieupparenkorean": "\u3205",
+ "/pieupsioskiyeokkorean": "\u3174",
+ "/pieupsioskorean": "\u3144",
+ "/pieupsiostikeutkorean": "\u3175",
+ "/pieupthieuthkorean": "\u3177",
+ "/pieuptikeutkorean": "\u3173",
+ "/pig": "\u1F416",
+ "/pigFace": "\u1F437",
+ "/pigNose": "\u1F43D",
+ "/pihiragana": "\u3074",
+ "/pikatakana": "\u30D4",
+ "/pikosquare": "\u3330",
+ "/pikurusquare": "\u332F",
+ "/pilcrowsignreversed": "\u204B",
+ "/pileOfPoo": "\u1F4A9",
+ "/pill": "\u1F48A",
+ "/pineDecoration": "\u1F38D",
+ "/pineapple": "\u1F34D",
+ "/pisces": "\u2653",
+ "/piselehpada": "\uA9CC",
+ "/pistol": "\u1F52B",
+ "/pisymbolgreek": "\u03D6",
+ "/pitchfork": "\u22D4",
+ "/piwrarmenian": "\u0583",
+ "/placeOfWorship": "\u1F6D0",
+ "/placeofinterestsign": "\u2318",
+ "/planck": "\u210E",
+ "/plancktwopi": "\u210F",
+ "/plus": "\u002B",
+ "/plus.inferior": "\u208A",
+ "/plus.superior": "\u207A",
+ "/plusbelowcmb": "\u031F",
+ "/pluscircle": "\u2295",
+ "/plusminus": "\u00B1",
+ "/plusmod": "\u02D6",
+ "/plusmonospace": "\uFF0B",
+ "/plussignalt:hb": "\uFB29",
+ "/plussignmod": "\u02D6",
+ "/plussmall": "\uFE62",
+ "/plussuperior": "\u207A",
+ "/pluto": "\u2647",
+ "/pmfullwidth": "\u33D8",
+ "/pmonospace": "\uFF50",
+ "/pmsquare": "\u33D8",
+ "/pocketCalculator": "\u1F5A9",
+ "/poeticverse": "\u060E",
+ "/pohiragana": "\u307D",
+ "/pointerleftblack": "\u25C4",
+ "/pointerleftwhite": "\u25C5",
+ "/pointerrightblack": "\u25BA",
+ "/pointerrightwhite": "\u25BB",
+ "/pointingindexdownwhite": "\u261F",
+ "/pointingindexleftblack": "\u261A",
+ "/pointingindexleftwhite": "\u261C",
+ "/pointingindexrightblack": "\u261B",
+ "/pointingindexrightwhite": "\u261E",
+ "/pointingindexupwhite": "\u261D",
+ "/pointingtriangledownheavywhite": "\u26DB",
+ "/pointosquare": "\u333D",
+ "/pointring": "\u2E30",
+ "/pokatakana": "\u30DD",
+ "/pokrytiecmbcyr": "\u0487",
+ "/policeCar": "\u1F693",
+ "/policeCarsRevolvingLight": "\u1F6A8",
+ "/policeOfficer": "\u1F46E",
+ "/pondosquare": "\u3340",
+ "/poodle": "\u1F429",
+ "/popcorn": "\u1F37F",
+ "/popdirectionalformatting": "\u202C",
+ "/popdirectionalisolate": "\u2069",
+ "/poplathai": "\u0E1B",
+ "/portableStereo": "\u1F4FE",
+ "/positionindicator": "\u2316",
+ "/postalHorn": "\u1F4EF",
+ "/postalmark": "\u3012",
+ "/postalmarkface": "\u3020",
+ "/postbox": "\u1F4EE",
+ "/potOfFood": "\u1F372",
+ "/potableWater": "\u1F6B0",
+ "/pouch": "\u1F45D",
+ "/poultryLeg": "\u1F357",
+ "/poutingCatFace": "\u1F63E",
+ "/poutingFace": "\u1F621",
+ "/power": "\u23FB",
+ "/poweron": "\u23FD",
+ "/poweronoff": "\u23FC",
+ "/powersleep": "\u23FE",
+ "/pparen": "\u24AB",
+ "/pparenthesized": "\u24AB",
+ "/ppmfullwidth": "\u33D9",
+ "/prayerBeads": "\u1F4FF",
+ "/precedes": "\u227A",
+ "/precedesbutnotequivalent": "\u22E8",
+ "/precedesorequal": "\u227C",
+ "/precedesorequivalent": "\u227E",
+ "/precedesunderrelation": "\u22B0",
+ "/prescription": "\u211E",
+ "/preversedepigraphic": "\uA7FC",
+ "/previouspage": "\u2397",
+ "/prfullwidth": "\u33DA",
+ "/primedblmod": "\u02BA",
+ "/primemod": "\u02B9",
+ "/primereversed": "\u2035",
+ "/princess": "\u1F478",
+ "/printer": "\u1F5A8",
+ "/printerIcon": "\u1F5B6",
+ "/printideographiccircled": "\u329E",
+ "/printscreen": "\u2399",
+ "/product": "\u220F",
+ "/prohibitedSign": "\u1F6C7",
+ "/projective": "\u2305",
+ "/prolongedkana": "\u30FC",
+ "/propellor": "\u2318",
+ "/propersubset": "\u2282",
+ "/propersuperset": "\u2283",
+ "/propertyline": "\u214A",
+ "/proportion": "\u2237",
+ "/proportional": "\u221D",
+ "/psfullwidth": "\u33B0",
+ "/psi": "\u03C8",
+ "/psicyr": "\u0471",
+ "/psicyrillic": "\u0471",
+ "/psilicmbcyr": "\u0486",
+ "/psilipneumatacyrilliccmb": "\u0486",
+ "/pssquare": "\u33B0",
+ "/pstrokedescender": "\uA751",
+ "/ptail": "\uA755",
+ "/publicAddressLoudspeaker": "\u1F4E2",
+ "/puhiragana": "\u3077",
+ "/pukatakana": "\u30D7",
+ "/punctuationspace": "\u2008",
+ "/purpleHeart": "\u1F49C",
+ "/purse": "\u1F45B",
+ "/pushpin": "\u1F4CC",
+ "/putLitterInItsPlace": "\u1F6AE",
+ "/pvfullwidth": "\u33B4",
+ "/pvsquare": "\u33B4",
+ "/pwfullwidth": "\u33BA",
+ "/pwsquare": "\u33BA",
+ "/q": "\u0071",
+ "/qacyr": "\u051B",
+ "/qadeva": "\u0958",
+ "/qadma:hb": "\u05A8",
+ "/qadmahebrew": "\u05A8",
+ "/qaf": "\u0642",
+ "/qaf.fina": "\uFED6",
+ "/qaf.init": "\uFED7",
+ "/qaf.init_alefmaksura.fina": "\uFC35",
+ "/qaf.init_hah.fina": "\uFC33",
+ "/qaf.init_hah.medi": "\uFCC2",
+ "/qaf.init_meem.fina": "\uFC34",
+ "/qaf.init_meem.medi": "\uFCC3",
+ "/qaf.init_meem.medi_hah.medi": "\uFDB4",
+ "/qaf.init_yeh.fina": "\uFC36",
+ "/qaf.isol": "\uFED5",
+ "/qaf.medi": "\uFED8",
+ "/qaf.medi_alefmaksura.fina": "\uFC7E",
+ "/qaf.medi_meem.medi_hah.fina": "\uFD7E",
+ "/qaf.medi_meem.medi_meem.fina": "\uFD7F",
+ "/qaf.medi_meem.medi_yeh.fina": "\uFDB2",
+ "/qaf.medi_yeh.fina": "\uFC7F",
+ "/qaf_lam_alefmaksuraabove": "\u06D7",
+ "/qafarabic": "\u0642",
+ "/qafdotabove": "\u06A7",
+ "/qaffinalarabic": "\uFED6",
+ "/qafinitialarabic": "\uFED7",
+ "/qafmedialarabic": "\uFED8",
+ "/qafthreedotsabove": "\u06A8",
+ "/qamats": "\u05B8",
+ "/qamats10": "\u05B8",
+ "/qamats1a": "\u05B8",
+ "/qamats1c": "\u05B8",
+ "/qamats27": "\u05B8",
+ "/qamats29": "\u05B8",
+ "/qamats33": "\u05B8",
+ "/qamats:hb": "\u05B8",
+ "/qamatsQatan:hb": "\u05C7",
+ "/qamatsde": "\u05B8",
+ "/qamatshebrew": "\u05B8",
+ "/qamatsnarrowhebrew": "\u05B8",
+ "/qamatsqatanhebrew": "\u05B8",
+ "/qamatsqatannarrowhebrew": "\u05B8",
+ "/qamatsqatanquarterhebrew": "\u05B8",
+ "/qamatsqatanwidehebrew": "\u05B8",
+ "/qamatsquarterhebrew": "\u05B8",
+ "/qamatswidehebrew": "\u05B8",
+ "/qarneFarah:hb": "\u059F",
+ "/qarneyparahebrew": "\u059F",
+ "/qbopomofo": "\u3111",
+ "/qcircle": "\u24E0",
+ "/qdiagonalstroke": "\uA759",
+ "/qhook": "\u02A0",
+ "/qhooktail": "\u024B",
+ "/qmonospace": "\uFF51",
+ "/qof": "\u05E7",
+ "/qof:hb": "\u05E7",
+ "/qofdagesh": "\uFB47",
+ "/qofdageshhebrew": "\uFB47",
+ "/qofhatafpatah": "\u05E7",
+ "/qofhatafpatahhebrew": "\u05E7",
+ "/qofhatafsegol": "\u05E7",
+ "/qofhatafsegolhebrew": "\u05E7",
+ "/qofhebrew": "\u05E7",
+ "/qofhiriq": "\u05E7",
+ "/qofhiriqhebrew": "\u05E7",
+ "/qofholam": "\u05E7",
+ "/qofholamhebrew": "\u05E7",
+ "/qofpatah": "\u05E7",
+ "/qofpatahhebrew": "\u05E7",
+ "/qofqamats": "\u05E7",
+ "/qofqamatshebrew": "\u05E7",
+ "/qofqubuts": "\u05E7",
+ "/qofqubutshebrew": "\u05E7",
+ "/qofsegol": "\u05E7",
+ "/qofsegolhebrew": "\u05E7",
+ "/qofsheva": "\u05E7",
+ "/qofshevahebrew": "\u05E7",
+ "/qoftsere": "\u05E7",
+ "/qoftserehebrew": "\u05E7",
+ "/qofwithdagesh:hb": "\uFB47",
+ "/qparen": "\u24AC",
+ "/qparenthesized": "\u24AC",
+ "/qpdigraph": "\u0239",
+ "/qstrokedescender": "\uA757",
+ "/quadarrowdownfunc": "\u2357",
+ "/quadarrowleftfunc": "\u2347",
+ "/quadarrowrightfunc": "\u2348",
+ "/quadarrowupfunc": "\u2350",
+ "/quadbackslashfunc": "\u2342",
+ "/quadcaretdownfunc": "\u234C",
+ "/quadcaretupfunc": "\u2353",
+ "/quadcirclefunc": "\u233C",
+ "/quadcolonfunc": "\u2360",
+ "/quaddelfunc": "\u2354",
+ "/quaddeltafunc": "\u234D",
+ "/quaddiamondfunc": "\u233A",
+ "/quaddividefunc": "\u2339",
+ "/quadequalfunc": "\u2338",
+ "/quadfunc": "\u2395",
+ "/quadgreaterfunc": "\u2344",
+ "/quadjotfunc": "\u233B",
+ "/quadlessfunc": "\u2343",
+ "/quadnotequalfunc": "\u236F",
+ "/quadquestionfunc": "\u2370",
+ "/quadrantLowerLeft": "\u2596",
+ "/quadrantLowerRight": "\u2597",
+ "/quadrantUpperLeft": "\u2598",
+ "/quadrantUpperLeftAndLowerLeftAndLowerRight": "\u2599",
+ "/quadrantUpperLeftAndLowerRight": "\u259A",
+ "/quadrantUpperLeftAndUpperRightAndLowerLeft": "\u259B",
+ "/quadrantUpperLeftAndUpperRightAndLowerRight": "\u259C",
+ "/quadrantUpperRight": "\u259D",
+ "/quadrantUpperRightAndLowerLeft": "\u259E",
+ "/quadrantUpperRightAndLowerLeftAndLowerRight": "\u259F",
+ "/quadrupleminute": "\u2057",
+ "/quadslashfunc": "\u2341",
+ "/quarternote": "\u2669",
+ "/qubuts": "\u05BB",
+ "/qubuts18": "\u05BB",
+ "/qubuts25": "\u05BB",
+ "/qubuts31": "\u05BB",
+ "/qubuts:hb": "\u05BB",
+ "/qubutshebrew": "\u05BB",
+ "/qubutsnarrowhebrew": "\u05BB",
+ "/qubutsquarterhebrew": "\u05BB",
+ "/qubutswidehebrew": "\u05BB",
+ "/queenblack": "\u265B",
+ "/queenwhite": "\u2655",
+ "/question": "\u003F",
+ "/questionarabic": "\u061F",
+ "/questionarmenian": "\u055E",
+ "/questiondbl": "\u2047",
+ "/questiondown": "\u00BF",
+ "/questiondownsmall": "\uF7BF",
+ "/questionedequal": "\u225F",
+ "/questionexclamationmark": "\u2048",
+ "/questiongreek": "\u037E",
+ "/questionideographiccircled": "\u3244",
+ "/questionmonospace": "\uFF1F",
+ "/questionreversed": "\u2E2E",
+ "/questionsmall": "\uF73F",
+ "/quincunx": "\u26BB",
+ "/quotedbl": "\u0022",
+ "/quotedblbase": "\u201E",
+ "/quotedblleft": "\u201C",
+ "/quotedbllowreversed": "\u2E42",
+ "/quotedblmonospace": "\uFF02",
+ "/quotedblprime": "\u301E",
+ "/quotedblprimereversed": "\u301D",
+ "/quotedblreversed": "\u201F",
+ "/quotedblright": "\u201D",
+ "/quoteleft": "\u2018",
+ "/quoteleftreversed": "\u201B",
+ "/quotequadfunc": "\u235E",
+ "/quotereversed": "\u201B",
+ "/quoteright": "\u2019",
+ "/quoterightn": "\u0149",
+ "/quotesinglbase": "\u201A",
+ "/quotesingle": "\u0027",
+ "/quotesinglemonospace": "\uFF07",
+ "/quoteunderlinefunc": "\u2358",
+ "/r": "\u0072",
+ "/raagung": "\uA9AC",
+ "/raarmenian": "\u057C",
+ "/rabbit": "\u1F407",
+ "/rabbitFace": "\u1F430",
+ "/rabengali": "\u09B0",
+ "/racingCar": "\u1F3CE",
+ "/racingMotorcycle": "\u1F3CD",
+ "/racirclekatakana": "\u32F6",
+ "/racute": "\u0155",
+ "/radeva": "\u0930",
+ "/radfullwidth": "\u33AD",
+ "/radical": "\u221A",
+ "/radicalbottom": "\u23B7",
+ "/radicalex": "\uF8E5",
+ "/radio": "\u1F4FB",
+ "/radioButton": "\u1F518",
+ "/radioactive": "\u2622",
+ "/radovers2fullwidth": "\u33AF",
+ "/radoversfullwidth": "\u33AE",
+ "/radoverssquare": "\u33AE",
+ "/radoverssquaredsquare": "\u33AF",
+ "/radsquare": "\u33AD",
+ "/rafe": "\u05BF",
+ "/rafe:hb": "\u05BF",
+ "/rafehebrew": "\u05BF",
+ "/ragujarati": "\u0AB0",
+ "/ragurmukhi": "\u0A30",
+ "/rahiragana": "\u3089",
+ "/railwayCar": "\u1F683",
+ "/railwayTrack": "\u1F6E4",
+ "/rain": "\u26C6",
+ "/rainbow": "\u1F308",
+ "/raisedHandFingersSplayed": "\u1F590",
+ "/raisedHandPartBetweenMiddleAndRingFingers": "\u1F596",
+ "/raisedmcsign": "\u1F16A",
+ "/raisedmdsign": "\u1F16B",
+ "/rakatakana": "\u30E9",
+ "/rakatakanahalfwidth": "\uFF97",
+ "/ralowerdiagonalbengali": "\u09F1",
+ "/ram": "\u1F40F",
+ "/ramiddlediagonalbengali": "\u09F0",
+ "/ramshorn": "\u0264",
+ "/rat": "\u1F400",
+ "/ratio": "\u2236",
+ "/ray": "\u0608",
+ "/rbopomofo": "\u3116",
+ "/rcaron": "\u0159",
+ "/rcedilla": "\u0157",
+ "/rcircle": "\u24E1",
+ "/rcommaaccent": "\u0157",
+ "/rdblgrave": "\u0211",
+ "/rdot": "\u1E59",
+ "/rdotaccent": "\u1E59",
+ "/rdotbelow": "\u1E5B",
+ "/rdotbelowmacron": "\u1E5D",
+ "/reachideographicparen": "\u3243",
+ "/recirclekatakana": "\u32F9",
+ "/recreationalVehicle": "\u1F699",
+ "/rectangleblack": "\u25AC",
+ "/rectangleverticalblack": "\u25AE",
+ "/rectangleverticalwhite": "\u25AF",
+ "/rectanglewhite": "\u25AD",
+ "/recycledpaper": "\u267C",
+ "/recyclefiveplastics": "\u2677",
+ "/recyclefourplastics": "\u2676",
+ "/recyclegeneric": "\u267A",
+ "/recycleoneplastics": "\u2673",
+ "/recyclepartiallypaper": "\u267D",
+ "/recyclesevenplastics": "\u2679",
+ "/recyclesixplastics": "\u2678",
+ "/recyclethreeplastics": "\u2675",
+ "/recycletwoplastics": "\u2674",
+ "/recycleuniversal": "\u2672",
+ "/recycleuniversalblack": "\u267B",
+ "/redApple": "\u1F34E",
+ "/redTriangleDOwn": "\u1F53B",
+ "/redTriangleUp": "\u1F53A",
+ "/referencemark": "\u203B",
+ "/reflexsubset": "\u2286",
+ "/reflexsuperset": "\u2287",
+ "/regionalindicatorsymbollettera": "\u1F1E6",
+ "/regionalindicatorsymbolletterb": "\u1F1E7",
+ "/regionalindicatorsymbolletterc": "\u1F1E8",
+ "/regionalindicatorsymbolletterd": "\u1F1E9",
+ "/regionalindicatorsymbollettere": "\u1F1EA",
+ "/regionalindicatorsymbolletterf": "\u1F1EB",
+ "/regionalindicatorsymbolletterg": "\u1F1EC",
+ "/regionalindicatorsymbolletterh": "\u1F1ED",
+ "/regionalindicatorsymbolletteri": "\u1F1EE",
+ "/regionalindicatorsymbolletterj": "\u1F1EF",
+ "/regionalindicatorsymbolletterk": "\u1F1F0",
+ "/regionalindicatorsymbolletterl": "\u1F1F1",
+ "/regionalindicatorsymbolletterm": "\u1F1F2",
+ "/regionalindicatorsymbollettern": "\u1F1F3",
+ "/regionalindicatorsymbollettero": "\u1F1F4",
+ "/regionalindicatorsymbolletterp": "\u1F1F5",
+ "/regionalindicatorsymbolletterq": "\u1F1F6",
+ "/regionalindicatorsymbolletterr": "\u1F1F7",
+ "/regionalindicatorsymbolletters": "\u1F1F8",
+ "/regionalindicatorsymbollettert": "\u1F1F9",
+ "/regionalindicatorsymbolletteru": "\u1F1FA",
+ "/regionalindicatorsymbolletterv": "\u1F1FB",
+ "/regionalindicatorsymbolletterw": "\u1F1FC",
+ "/regionalindicatorsymbolletterx": "\u1F1FD",
+ "/regionalindicatorsymbollettery": "\u1F1FE",
+ "/regionalindicatorsymbolletterz": "\u1F1FF",
+ "/registered": "\u00AE",
+ "/registersans": "\uF8E8",
+ "/registerserif": "\uF6DA",
+ "/reh.fina": "\uFEAE",
+ "/reh.init_superscriptalef.fina": "\uFC5C",
+ "/reh.isol": "\uFEAD",
+ "/rehHamzaAbove": "\u076C",
+ "/rehSmallTahTwoDots": "\u0771",
+ "/rehStroke": "\u075B",
+ "/rehTwoDotsVerticallyAbove": "\u076B",
+ "/rehVabove": "\u0692",
+ "/rehVbelow": "\u0695",
+ "/reharabic": "\u0631",
+ "/reharmenian": "\u0580",
+ "/rehdotbelow": "\u0694",
+ "/rehdotbelowdotabove": "\u0696",
+ "/rehfinalarabic": "\uFEAE",
+ "/rehfourdotsabove": "\u0699",
+ "/rehinvertedV": "\u06EF",
+ "/rehiragana": "\u308C",
+ "/rehring": "\u0693",
+ "/rehtwodotsabove": "\u0697",
+ "/rehyehaleflamarabic": "\u0631",
+ "/rekatakana": "\u30EC",
+ "/rekatakanahalfwidth": "\uFF9A",
+ "/relievedFace": "\u1F60C",
+ "/religionideographiccircled": "\u32AA",
+ "/reminderRibbon": "\u1F397",
+ "/remusquare": "\u3355",
+ "/rentogensquare": "\u3356",
+ "/replacementchar": "\uFFFD",
+ "/replacementcharobj": "\uFFFC",
+ "/representideographicparen": "\u3239",
+ "/rerengganleft": "\uA9C1",
+ "/rerengganright": "\uA9C2",
+ "/resh": "\u05E8",
+ "/resh:hb": "\u05E8",
+ "/reshdageshhebrew": "\uFB48",
+ "/reshhatafpatah": "\u05E8",
+ "/reshhatafpatahhebrew": "\u05E8",
+ "/reshhatafsegol": "\u05E8",
+ "/reshhatafsegolhebrew": "\u05E8",
+ "/reshhebrew": "\u05E8",
+ "/reshhiriq": "\u05E8",
+ "/reshhiriqhebrew": "\u05E8",
+ "/reshholam": "\u05E8",
+ "/reshholamhebrew": "\u05E8",
+ "/reshpatah": "\u05E8",
+ "/reshpatahhebrew": "\u05E8",
+ "/reshqamats": "\u05E8",
+ "/reshqamatshebrew": "\u05E8",
+ "/reshqubuts": "\u05E8",
+ "/reshqubutshebrew": "\u05E8",
+ "/reshsegol": "\u05E8",
+ "/reshsegolhebrew": "\u05E8",
+ "/reshsheva": "\u05E8",
+ "/reshshevahebrew": "\u05E8",
+ "/reshtsere": "\u05E8",
+ "/reshtserehebrew": "\u05E8",
+ "/reshwide:hb": "\uFB27",
+ "/reshwithdagesh:hb": "\uFB48",
+ "/resourceideographiccircled": "\u32AE",
+ "/resourceideographicparen": "\u323E",
+ "/response": "\u211F",
+ "/restideographiccircled": "\u32A1",
+ "/restideographicparen": "\u3241",
+ "/restrictedentryoneleft": "\u26E0",
+ "/restrictedentrytwoleft": "\u26E1",
+ "/restroom": "\u1F6BB",
+ "/return": "\u23CE",
+ "/reversedHandMiddleFingerExtended": "\u1F595",
+ "/reversedRaisedHandFingersSplayed": "\u1F591",
+ "/reversedThumbsDownSign": "\u1F593",
+ "/reversedThumbsUpSign": "\u1F592",
+ "/reversedVictoryHand": "\u1F594",
+ "/reversedonehundred.roman": "\u2183",
+ "/reversedtilde": "\u223D",
+ "/reversedzecyr": "\u0511",
+ "/revia:hb": "\u0597",
+ "/reviahebrew": "\u0597",
+ "/reviamugrashhebrew": "\u0597",
+ "/revlogicalnot": "\u2310",
+ "/revolvingHearts": "\u1F49E",
+ "/rfishhook": "\u027E",
+ "/rfishhookreversed": "\u027F",
+ "/rgravedbl": "\u0211",
+ "/rhabengali": "\u09DD",
+ "/rhacyr": "\u0517",
+ "/rhadeva": "\u095D",
+ "/rho": "\u03C1",
+ "/rhoasper": "\u1FE5",
+ "/rhofunc": "\u2374",
+ "/rholenis": "\u1FE4",
+ "/rhook": "\u027D",
+ "/rhookturned": "\u027B",
+ "/rhookturnedsuperior": "\u02B5",
+ "/rhookturnedsupmod": "\u02B5",
+ "/rhostrokesymbol": "\u03FC",
+ "/rhosymbol": "\u03F1",
+ "/rhosymbolgreek": "\u03F1",
+ "/rhotichookmod": "\u02DE",
+ "/rial": "\uFDFC",
+ "/ribbon": "\u1F380",
+ "/riceBall": "\u1F359",
+ "/riceCracker": "\u1F358",
+ "/ricirclekatakana": "\u32F7",
+ "/rieulacirclekorean": "\u3271",
+ "/rieulaparenkorean": "\u3211",
+ "/rieulcirclekorean": "\u3263",
+ "/rieulhieuhkorean": "\u3140",
+ "/rieulkiyeokkorean": "\u313A",
+ "/rieulkiyeoksioskorean": "\u3169",
+ "/rieulkorean": "\u3139",
+ "/rieulmieumkorean": "\u313B",
+ "/rieulpansioskorean": "\u316C",
+ "/rieulparenkorean": "\u3203",
+ "/rieulphieuphkorean": "\u313F",
+ "/rieulpieupkorean": "\u313C",
+ "/rieulpieupsioskorean": "\u316B",
+ "/rieulsioskorean": "\u313D",
+ "/rieulthieuthkorean": "\u313E",
+ "/rieultikeutkorean": "\u316A",
+ "/rieulyeorinhieuhkorean": "\u316D",
+ "/right-pointingMagnifyingGlass": "\u1F50E",
+ "/rightAngerBubble": "\u1F5EF",
+ "/rightHalfBlock": "\u2590",
+ "/rightHandTelephoneReceiver": "\u1F57D",
+ "/rightOneEighthBlock": "\u2595",
+ "/rightSpeaker": "\u1F568",
+ "/rightSpeakerOneSoundWave": "\u1F569",
+ "/rightSpeakerThreeSoundWaves": "\u1F56A",
+ "/rightSpeechBubble": "\u1F5E9",
+ "/rightThoughtBubble": "\u1F5ED",
+ "/rightangle": "\u221F",
+ "/rightarrowoverleftarrow": "\u21C4",
+ "/rightdnheavyleftuplight": "\u2546",
+ "/rightharpoonoverleftharpoon": "\u21CC",
+ "/rightheavyleftdnlight": "\u252E",
+ "/rightheavyleftuplight": "\u2536",
+ "/rightheavyleftvertlight": "\u253E",
+ "/rightideographiccircled": "\u32A8",
+ "/rightlightleftdnheavy": "\u2531",
+ "/rightlightleftupheavy": "\u2539",
+ "/rightlightleftvertheavy": "\u2549",
+ "/righttackbelowcmb": "\u0319",
+ "/righttoleftembed": "\u202B",
+ "/righttoleftisolate": "\u2067",
+ "/righttoleftmark": "\u200F",
+ "/righttoleftoverride": "\u202E",
+ "/righttriangle": "\u22BF",
+ "/rightupheavyleftdnlight": "\u2544",
+ "/rihiragana": "\u308A",
+ "/rikatakana": "\u30EA",
+ "/rikatakanahalfwidth": "\uFF98",
+ "/ring": "\u02DA",
+ "/ringbelowcmb": "\u0325",
+ "/ringcmb": "\u030A",
+ "/ringequal": "\u2257",
+ "/ringhalfleft": "\u02BF",
+ "/ringhalfleftarmenian": "\u0559",
+ "/ringhalfleftbelowcmb": "\u031C",
+ "/ringhalfleftcentered": "\u02D3",
+ "/ringhalfleftcentredmod": "\u02D3",
+ "/ringhalfleftmod": "\u02BF",
+ "/ringhalfright": "\u02BE",
+ "/ringhalfrightbelowcmb": "\u0339",
+ "/ringhalfrightcentered": "\u02D2",
+ "/ringhalfrightcentredmod": "\u02D2",
+ "/ringhalfrightmod": "\u02BE",
+ "/ringinequal": "\u2256",
+ "/ringingBell": "\u1F56D",
+ "/ringlowmod": "\u02F3",
+ "/ringoperator": "\u2218",
+ "/rinsular": "\uA783",
+ "/rinvertedbreve": "\u0213",
+ "/rirasquare": "\u3352",
+ "/risingdiagonal": "\u27CB",
+ "/rittorusquare": "\u3351",
+ "/rlinebelow": "\u1E5F",
+ "/rlongleg": "\u027C",
+ "/rlonglegturned": "\u027A",
+ "/rmacrondot": "\u1E5D",
+ "/rmonospace": "\uFF52",
+ "/rnoon": "\u06BB",
+ "/rnoon.fina": "\uFBA1",
+ "/rnoon.init": "\uFBA2",
+ "/rnoon.isol": "\uFBA0",
+ "/rnoon.medi": "\uFBA3",
+ "/roastedSweetPotato": "\u1F360",
+ "/robliquestroke": "\uA7A7",
+ "/rocirclekatakana": "\u32FA",
+ "/rocket": "\u1F680",
+ "/rohiragana": "\u308D",
+ "/rokatakana": "\u30ED",
+ "/rokatakanahalfwidth": "\uFF9B",
+ "/rolled-upNewspaper": "\u1F5DE",
+ "/rollerCoaster": "\u1F3A2",
+ "/rookblack": "\u265C",
+ "/rookwhite": "\u2656",
+ "/rooster": "\u1F413",
+ "/roruathai": "\u0E23",
+ "/rose": "\u1F339",
+ "/rosette": "\u1F3F5",
+ "/roundPushpin": "\u1F4CD",
+ "/roundedzeroabove": "\u06DF",
+ "/rowboat": "\u1F6A3",
+ "/rparen": "\u24AD",
+ "/rparenthesized": "\u24AD",
+ "/rrabengali": "\u09DC",
+ "/rradeva": "\u0931",
+ "/rragurmukhi": "\u0A5C",
+ "/rreh": "\u0691",
+ "/rreh.fina": "\uFB8D",
+ "/rreh.isol": "\uFB8C",
+ "/rreharabic": "\u0691",
+ "/rrehfinalarabic": "\uFB8D",
+ "/rrotunda": "\uA75B",
+ "/rrvocalicbengali": "\u09E0",
+ "/rrvocalicdeva": "\u0960",
+ "/rrvocalicgujarati": "\u0AE0",
+ "/rrvocalicvowelsignbengali": "\u09C4",
+ "/rrvocalicvowelsigndeva": "\u0944",
+ "/rrvocalicvowelsigngujarati": "\u0AC4",
+ "/rstroke": "\u024D",
+ "/rsuperior": "\uF6F1",
+ "/rsupmod": "\u02B3",
+ "/rtailturned": "\u2C79",
+ "/rtblock": "\u2590",
+ "/rturned": "\u0279",
+ "/rturnedsuperior": "\u02B4",
+ "/rturnedsupmod": "\u02B4",
+ "/ruble": "\u20BD",
+ "/rucirclekatakana": "\u32F8",
+ "/rugbyFootball": "\u1F3C9",
+ "/ruhiragana": "\u308B",
+ "/rukatakana": "\u30EB",
+ "/rukatakanahalfwidth": "\uFF99",
+ "/rum": "\uA775",
+ "/rumrotunda": "\uA75D",
+ "/runner": "\u1F3C3",
+ "/runningShirtSash": "\u1F3BD",
+ "/rupeemarkbengali": "\u09F2",
+ "/rupeesignbengali": "\u09F3",
+ "/rupiah": "\uF6DD",
+ "/rupiisquare": "\u3353",
+ "/ruthai": "\u0E24",
+ "/ruuburusquare": "\u3354",
+ "/rvocalicbengali": "\u098B",
+ "/rvocalicdeva": "\u090B",
+ "/rvocalicgujarati": "\u0A8B",
+ "/rvocalicvowelsignbengali": "\u09C3",
+ "/rvocalicvowelsigndeva": "\u0943",
+ "/rvocalicvowelsigngujarati": "\u0AC3",
+ "/s": "\u0073",
+ "/s.inferior": "\u209B",
+ "/s_t": "\uFB06",
+ "/sabengali": "\u09B8",
+ "/sacirclekatakana": "\u32DA",
+ "/sacute": "\u015B",
+ "/sacutedotaccent": "\u1E65",
+ "/sad": "\u0635",
+ "/sad.fina": "\uFEBA",
+ "/sad.init": "\uFEBB",
+ "/sad.init_alefmaksura.fina": "\uFD05",
+ "/sad.init_hah.fina": "\uFC20",
+ "/sad.init_hah.medi": "\uFCB1",
+ "/sad.init_hah.medi_hah.medi": "\uFD65",
+ "/sad.init_khah.medi": "\uFCB2",
+ "/sad.init_meem.fina": "\uFC21",
+ "/sad.init_meem.medi": "\uFCB3",
+ "/sad.init_meem.medi_meem.medi": "\uFDC5",
+ "/sad.init_reh.fina": "\uFD0F",
+ "/sad.init_yeh.fina": "\uFD06",
+ "/sad.isol": "\uFEB9",
+ "/sad.medi": "\uFEBC",
+ "/sad.medi_alefmaksura.fina": "\uFD21",
+ "/sad.medi_hah.medi_hah.fina": "\uFD64",
+ "/sad.medi_hah.medi_yeh.fina": "\uFDA9",
+ "/sad.medi_meem.medi_meem.fina": "\uFD66",
+ "/sad.medi_reh.fina": "\uFD2B",
+ "/sad.medi_yeh.fina": "\uFD22",
+ "/sad_lam_alefmaksuraabove": "\u06D6",
+ "/sadarabic": "\u0635",
+ "/sadeva": "\u0938",
+ "/sadfinalarabic": "\uFEBA",
+ "/sadinitialarabic": "\uFEBB",
+ "/sadmedialarabic": "\uFEBC",
+ "/sadthreedotsabove": "\u069E",
+ "/sadtwodotsbelow": "\u069D",
+ "/sagittarius": "\u2650",
+ "/sagujarati": "\u0AB8",
+ "/sagurmukhi": "\u0A38",
+ "/sahiragana": "\u3055",
+ "/saikurusquare": "\u331F",
+ "/sailboat": "\u26F5",
+ "/sakatakana": "\u30B5",
+ "/sakatakanahalfwidth": "\uFF7B",
+ "/sakeBottleAndCup": "\u1F376",
+ "/sallallahoualayhewasallamarabic": "\uFDFA",
+ "/saltillo": "\uA78C",
+ "/saltire": "\u2613",
+ "/samahaprana": "\uA9B0",
+ "/samekh": "\u05E1",
+ "/samekh:hb": "\u05E1",
+ "/samekhdagesh": "\uFB41",
+ "/samekhdageshhebrew": "\uFB41",
+ "/samekhhebrew": "\u05E1",
+ "/samekhwithdagesh:hb": "\uFB41",
+ "/sampi": "\u03E1",
+ "/sampiarchaic": "\u0373",
+ "/samurda": "\uA9AF",
+ "/samvat": "\u0604",
+ "/san": "\u03FB",
+ "/santiimusquare": "\u3320",
+ "/saraaathai": "\u0E32",
+ "/saraaethai": "\u0E41",
+ "/saraaimaimalaithai": "\u0E44",
+ "/saraaimaimuanthai": "\u0E43",
+ "/saraamthai": "\u0E33",
+ "/saraathai": "\u0E30",
+ "/saraethai": "\u0E40",
+ "/saraiileftthai": "\uF886",
+ "/saraiithai": "\u0E35",
+ "/saraileftthai": "\uF885",
+ "/saraithai": "\u0E34",
+ "/saraothai": "\u0E42",
+ "/saraueeleftthai": "\uF888",
+ "/saraueethai": "\u0E37",
+ "/saraueleftthai": "\uF887",
+ "/sarauethai": "\u0E36",
+ "/sarauthai": "\u0E38",
+ "/sarauuthai": "\u0E39",
+ "/satellite": "\u1F6F0",
+ "/satelliteAntenna": "\u1F4E1",
+ "/saturn": "\u2644",
+ "/saxophone": "\u1F3B7",
+ "/sbopomofo": "\u3119",
+ "/scales": "\u2696",
+ "/scanninehorizontal": "\u23BD",
+ "/scanonehorizontal": "\u23BA",
+ "/scansevenhorizontal": "\u23BC",
+ "/scanthreehorizontal": "\u23BB",
+ "/scaron": "\u0161",
+ "/scarondot": "\u1E67",
+ "/scarondotaccent": "\u1E67",
+ "/scedilla": "\u015F",
+ "/school": "\u1F3EB",
+ "/schoolSatchel": "\u1F392",
+ "/schoolideographiccircled": "\u3246",
+ "/schwa": "\u0259",
+ "/schwa.inferior": "\u2094",
+ "/schwacyr": "\u04D9",
+ "/schwacyrillic": "\u04D9",
+ "/schwadieresiscyr": "\u04DB",
+ "/schwadieresiscyrillic": "\u04DB",
+ "/schwahook": "\u025A",
+ "/scircle": "\u24E2",
+ "/scircumflex": "\u015D",
+ "/scommaaccent": "\u0219",
+ "/scooter": "\u1F6F4",
+ "/scorpius": "\u264F",
+ "/screen": "\u1F5B5",
+ "/scroll": "\u1F4DC",
+ "/scruple": "\u2108",
+ "/sdot": "\u1E61",
+ "/sdotaccent": "\u1E61",
+ "/sdotbelow": "\u1E63",
+ "/sdotbelowdotabove": "\u1E69",
+ "/sdotbelowdotaccent": "\u1E69",
+ "/seagullbelowcmb": "\u033C",
+ "/seat": "\u1F4BA",
+ "/secirclekatakana": "\u32DD",
+ "/second": "\u2033",
+ "/secondreversed": "\u2036",
+ "/secondscreensquare": "\u1F19C",
+ "/secondtonechinese": "\u02CA",
+ "/secretideographiccircled": "\u3299",
+ "/section": "\u00A7",
+ "/sectionsignhalftop": "\u2E39",
+ "/sector": "\u2314",
+ "/seeNoEvilMonkey": "\u1F648",
+ "/seedling": "\u1F331",
+ "/seen": "\u0633",
+ "/seen.fina": "\uFEB2",
+ "/seen.init": "\uFEB3",
+ "/seen.init_alefmaksura.fina": "\uFCFB",
+ "/seen.init_hah.fina": "\uFC1D",
+ "/seen.init_hah.medi": "\uFCAE",
+ "/seen.init_hah.medi_jeem.medi": "\uFD5C",
+ "/seen.init_heh.medi": "\uFD31",
+ "/seen.init_jeem.fina": "\uFC1C",
+ "/seen.init_jeem.medi": "\uFCAD",
+ "/seen.init_jeem.medi_hah.medi": "\uFD5D",
+ "/seen.init_khah.fina": "\uFC1E",
+ "/seen.init_khah.medi": "\uFCAF",
+ "/seen.init_meem.fina": "\uFC1F",
+ "/seen.init_meem.medi": "\uFCB0",
+ "/seen.init_meem.medi_hah.medi": "\uFD60",
+ "/seen.init_meem.medi_jeem.medi": "\uFD61",
+ "/seen.init_meem.medi_meem.medi": "\uFD63",
+ "/seen.init_reh.fina": "\uFD0E",
+ "/seen.init_yeh.fina": "\uFCFC",
+ "/seen.isol": "\uFEB1",
+ "/seen.medi": "\uFEB4",
+ "/seen.medi_alefmaksura.fina": "\uFD17",
+ "/seen.medi_hah.medi": "\uFD35",
+ "/seen.medi_heh.medi": "\uFCE8",
+ "/seen.medi_jeem.medi": "\uFD34",
+ "/seen.medi_jeem.medi_alefmaksura.fina": "\uFD5E",
+ "/seen.medi_khah.medi": "\uFD36",
+ "/seen.medi_khah.medi_alefmaksura.fina": "\uFDA8",
+ "/seen.medi_khah.medi_yeh.fina": "\uFDC6",
+ "/seen.medi_meem.medi": "\uFCE7",
+ "/seen.medi_meem.medi_hah.fina": "\uFD5F",
+ "/seen.medi_meem.medi_meem.fina": "\uFD62",
+ "/seen.medi_reh.fina": "\uFD2A",
+ "/seen.medi_yeh.fina": "\uFD18",
+ "/seenDigitFourAbove": "\u077D",
+ "/seenFourDotsAbove": "\u075C",
+ "/seenInvertedV": "\u077E",
+ "/seenSmallTahTwoDots": "\u0770",
+ "/seenTwoDotsVerticallyAbove": "\u076D",
+ "/seenabove": "\u06DC",
+ "/seenarabic": "\u0633",
+ "/seendotbelowdotabove": "\u069A",
+ "/seenfinalarabic": "\uFEB2",
+ "/seeninitialarabic": "\uFEB3",
+ "/seenlow": "\u06E3",
+ "/seenmedialarabic": "\uFEB4",
+ "/seenthreedotsbelow": "\u069B",
+ "/seenthreedotsbelowthreedotsabove": "\u069C",
+ "/segment": "\u2313",
+ "/segol": "\u05B6",
+ "/segol13": "\u05B6",
+ "/segol1f": "\u05B6",
+ "/segol2c": "\u05B6",
+ "/segol:hb": "\u05B6",
+ "/segolhebrew": "\u05B6",
+ "/segolnarrowhebrew": "\u05B6",
+ "/segolquarterhebrew": "\u05B6",
+ "/segolta:hb": "\u0592",
+ "/segoltahebrew": "\u0592",
+ "/segolwidehebrew": "\u05B6",
+ "/seharmenian": "\u057D",
+ "/sehiragana": "\u305B",
+ "/sekatakana": "\u30BB",
+ "/sekatakanahalfwidth": "\uFF7E",
+ "/selfideographicparen": "\u3242",
+ "/semicolon": "\u003B",
+ "/semicolonarabic": "\u061B",
+ "/semicolonmonospace": "\uFF1B",
+ "/semicolonreversed": "\u204F",
+ "/semicolonsmall": "\uFE54",
+ "/semicolonunderlinefunc": "\u236E",
+ "/semidirectproductleft": "\u22CB",
+ "/semidirectproductright": "\u22CC",
+ "/semisextile": "\u26BA",
+ "/semisoftcyr": "\u048D",
+ "/semivoicedmarkkana": "\u309C",
+ "/semivoicedmarkkanahalfwidth": "\uFF9F",
+ "/sentisquare": "\u3322",
+ "/sentosquare": "\u3323",
+ "/septembertelegraph": "\u32C8",
+ "/sersetdblup": "\u22D1",
+ "/sersetnotequalup": "\u228B",
+ "/servicemark": "\u2120",
+ "/sesamedot": "\uFE45",
+ "/sesquiquadrate": "\u26BC",
+ "/setminus": "\u2216",
+ "/seven": "\u0037",
+ "/seven.inferior": "\u2087",
+ "/seven.roman": "\u2166",
+ "/seven.romansmall": "\u2176",
+ "/seven.superior": "\u2077",
+ "/sevenarabic": "\u0667",
+ "/sevenbengali": "\u09ED",
+ "/sevencircle": "\u2466",
+ "/sevencircledbl": "\u24FB",
+ "/sevencircleinversesansserif": "\u2790",
+ "/sevencomma": "\u1F108",
+ "/sevendeva": "\u096D",
+ "/seveneighths": "\u215E",
+ "/sevenfar": "\u06F7",
+ "/sevengujarati": "\u0AED",
+ "/sevengurmukhi": "\u0A6D",
+ "/sevenhackarabic": "\u0667",
+ "/sevenhangzhou": "\u3027",
+ "/sevenideographiccircled": "\u3286",
+ "/sevenideographicparen": "\u3226",
+ "/seveninferior": "\u2087",
+ "/sevenmonospace": "\uFF17",
+ "/sevenoldstyle": "\uF737",
+ "/sevenparen": "\u247A",
+ "/sevenparenthesized": "\u247A",
+ "/sevenperiod": "\u248E",
+ "/sevenpersian": "\u06F7",
+ "/sevenpointonesquare": "\u1F1A1",
+ "/sevenroman": "\u2176",
+ "/sevensuperior": "\u2077",
+ "/seventeencircle": "\u2470",
+ "/seventeencircleblack": "\u24F1",
+ "/seventeenparen": "\u2484",
+ "/seventeenparenthesized": "\u2484",
+ "/seventeenperiod": "\u2498",
+ "/seventhai": "\u0E57",
+ "/seventycirclesquare": "\u324E",
+ "/sextile": "\u26B9",
+ "/sfthyphen": "\u00AD",
+ "/shaarmenian": "\u0577",
+ "/shabengali": "\u09B6",
+ "/shacyr": "\u0448",
+ "/shacyrillic": "\u0448",
+ "/shaddaAlefIsol": "\uFC63",
+ "/shaddaDammaIsol": "\uFC61",
+ "/shaddaDammaMedi": "\uFCF3",
+ "/shaddaDammatanIsol": "\uFC5E",
+ "/shaddaFathaIsol": "\uFC60",
+ "/shaddaFathaMedi": "\uFCF2",
+ "/shaddaIsol": "\uFE7C",
+ "/shaddaKasraIsol": "\uFC62",
+ "/shaddaKasraMedi": "\uFCF4",
+ "/shaddaKasratanIsol": "\uFC5F",
+ "/shaddaMedi": "\uFE7D",
+ "/shaddaarabic": "\u0651",
+ "/shaddadammaarabic": "\uFC61",
+ "/shaddadammatanarabic": "\uFC5E",
+ "/shaddafathaarabic": "\uFC60",
+ "/shaddafathatanarabic": "\u0651",
+ "/shaddakasraarabic": "\uFC62",
+ "/shaddakasratanarabic": "\uFC5F",
+ "/shade": "\u2592",
+ "/shadedark": "\u2593",
+ "/shadelight": "\u2591",
+ "/shademedium": "\u2592",
+ "/shadeva": "\u0936",
+ "/shagujarati": "\u0AB6",
+ "/shagurmukhi": "\u0A36",
+ "/shalshelet:hb": "\u0593",
+ "/shalshelethebrew": "\u0593",
+ "/shamrock": "\u2618",
+ "/shavedIce": "\u1F367",
+ "/shbopomofo": "\u3115",
+ "/shchacyr": "\u0449",
+ "/shchacyrillic": "\u0449",
+ "/sheen": "\u0634",
+ "/sheen.fina": "\uFEB6",
+ "/sheen.init": "\uFEB7",
+ "/sheen.init_alefmaksura.fina": "\uFCFD",
+ "/sheen.init_hah.fina": "\uFD0A",
+ "/sheen.init_hah.medi": "\uFD2E",
+ "/sheen.init_hah.medi_meem.medi": "\uFD68",
+ "/sheen.init_heh.medi": "\uFD32",
+ "/sheen.init_jeem.fina": "\uFD09",
+ "/sheen.init_jeem.medi": "\uFD2D",
+ "/sheen.init_khah.fina": "\uFD0B",
+ "/sheen.init_khah.medi": "\uFD2F",
+ "/sheen.init_meem.fina": "\uFD0C",
+ "/sheen.init_meem.medi": "\uFD30",
+ "/sheen.init_meem.medi_khah.medi": "\uFD6B",
+ "/sheen.init_meem.medi_meem.medi": "\uFD6D",
+ "/sheen.init_reh.fina": "\uFD0D",
+ "/sheen.init_yeh.fina": "\uFCFE",
+ "/sheen.isol": "\uFEB5",
+ "/sheen.medi": "\uFEB8",
+ "/sheen.medi_alefmaksura.fina": "\uFD19",
+ "/sheen.medi_hah.fina": "\uFD26",
+ "/sheen.medi_hah.medi": "\uFD38",
+ "/sheen.medi_hah.medi_meem.fina": "\uFD67",
+ "/sheen.medi_hah.medi_yeh.fina": "\uFDAA",
+ "/sheen.medi_heh.medi": "\uFCEA",
+ "/sheen.medi_jeem.fina": "\uFD25",
+ "/sheen.medi_jeem.medi": "\uFD37",
+ "/sheen.medi_jeem.medi_yeh.fina": "\uFD69",
+ "/sheen.medi_khah.fina": "\uFD27",
+ "/sheen.medi_khah.medi": "\uFD39",
+ "/sheen.medi_meem.fina": "\uFD28",
+ "/sheen.medi_meem.medi": "\uFCE9",
+ "/sheen.medi_meem.medi_khah.fina": "\uFD6A",
+ "/sheen.medi_meem.medi_meem.fina": "\uFD6C",
+ "/sheen.medi_reh.fina": "\uFD29",
+ "/sheen.medi_yeh.fina": "\uFD1A",
+ "/sheenarabic": "\u0634",
+ "/sheendotbelow": "\u06FA",
+ "/sheenfinalarabic": "\uFEB6",
+ "/sheeninitialarabic": "\uFEB7",
+ "/sheenmedialarabic": "\uFEB8",
+ "/sheep": "\u1F411",
+ "/sheicoptic": "\u03E3",
+ "/shelfmod": "\u02FD",
+ "/shelfopenmod": "\u02FE",
+ "/sheqel": "\u20AA",
+ "/sheqelhebrew": "\u20AA",
+ "/sheva": "\u05B0",
+ "/sheva115": "\u05B0",
+ "/sheva15": "\u05B0",
+ "/sheva22": "\u05B0",
+ "/sheva2e": "\u05B0",
+ "/sheva:hb": "\u05B0",
+ "/shevahebrew": "\u05B0",
+ "/shevanarrowhebrew": "\u05B0",
+ "/shevaquarterhebrew": "\u05B0",
+ "/shevawidehebrew": "\u05B0",
+ "/shhacyr": "\u04BB",
+ "/shhacyrillic": "\u04BB",
+ "/shhatailcyr": "\u0527",
+ "/shield": "\u1F6E1",
+ "/shimacoptic": "\u03ED",
+ "/shin": "\u05E9",
+ "/shin:hb": "\u05E9",
+ "/shinDot:hb": "\u05C1",
+ "/shindagesh": "\uFB49",
+ "/shindageshhebrew": "\uFB49",
+ "/shindageshshindot": "\uFB2C",
+ "/shindageshshindothebrew": "\uFB2C",
+ "/shindageshsindot": "\uFB2D",
+ "/shindageshsindothebrew": "\uFB2D",
+ "/shindothebrew": "\u05C1",
+ "/shinhebrew": "\u05E9",
+ "/shinshindot": "\uFB2A",
+ "/shinshindothebrew": "\uFB2A",
+ "/shinsindot": "\uFB2B",
+ "/shinsindothebrew": "\uFB2B",
+ "/shintoshrine": "\u26E9",
+ "/shinwithdagesh:hb": "\uFB49",
+ "/shinwithdageshandshinDot:hb": "\uFB2C",
+ "/shinwithdageshandsinDot:hb": "\uFB2D",
+ "/shinwithshinDot:hb": "\uFB2A",
+ "/shinwithsinDot:hb": "\uFB2B",
+ "/ship": "\u1F6A2",
+ "/sho": "\u03F8",
+ "/shoejotupfunc": "\u235D",
+ "/shoestiledownfunc": "\u2366",
+ "/shoestileleftfunc": "\u2367",
+ "/shogipieceblack": "\u2617",
+ "/shogipiecewhite": "\u2616",
+ "/shook": "\u0282",
+ "/shootingStar": "\u1F320",
+ "/shoppingBags": "\u1F6CD",
+ "/shoppingTrolley": "\u1F6D2",
+ "/shortcake": "\u1F370",
+ "/shortequalsmod": "\uA78A",
+ "/shortoverlongmetrical": "\u23D3",
+ "/shoulderedopenbox": "\u237D",
+ "/shower": "\u1F6BF",
+ "/shvsquare": "\u1F1AA",
+ "/sicirclekatakana": "\u32DB",
+ "/sidewaysBlackDownPointingIndex": "\u1F5A1",
+ "/sidewaysBlackLeftPointingIndex": "\u1F59A",
+ "/sidewaysBlackRightPointingIndex": "\u1F59B",
+ "/sidewaysBlackUpPointingIndex": "\u1F5A0",
+ "/sidewaysWhiteDownPointingIndex": "\u1F59F",
+ "/sidewaysWhiteLeftPointingIndex": "\u1F598",
+ "/sidewaysWhiteRightPointingIndex": "\u1F599",
+ "/sidewaysWhiteUpPointingIndex": "\u1F59E",
+ "/sigma": "\u03C3",
+ "/sigma1": "\u03C2",
+ "/sigmafinal": "\u03C2",
+ "/sigmalunatedottedreversedsymbol": "\u037D",
+ "/sigmalunatedottedsymbol": "\u037C",
+ "/sigmalunatereversedsymbol": "\u037B",
+ "/sigmalunatesymbol": "\u03F2",
+ "/sigmalunatesymbolgreek": "\u03F2",
+ "/sihiragana": "\u3057",
+ "/sikatakana": "\u30B7",
+ "/sikatakanahalfwidth": "\uFF7C",
+ "/silhouetteOfJapan": "\u1F5FE",
+ "/siluqhebrew": "\u05BD",
+ "/siluqlefthebrew": "\u05BD",
+ "/similar": "\u223C",
+ "/sinDot:hb": "\u05C2",
+ "/sindothebrew": "\u05C2",
+ "/sinewave": "\u223F",
+ "/sinh:a": "\u0D85",
+ "/sinh:aa": "\u0D86",
+ "/sinh:aae": "\u0D88",
+ "/sinh:aaesign": "\u0DD1",
+ "/sinh:aasign": "\u0DCF",
+ "/sinh:ae": "\u0D87",
+ "/sinh:aesign": "\u0DD0",
+ "/sinh:ai": "\u0D93",
+ "/sinh:aisign": "\u0DDB",
+ "/sinh:anusvara": "\u0D82",
+ "/sinh:au": "\u0D96",
+ "/sinh:ausign": "\u0DDE",
+ "/sinh:ba": "\u0DB6",
+ "/sinh:bha": "\u0DB7",
+ "/sinh:ca": "\u0DA0",
+ "/sinh:cha": "\u0DA1",
+ "/sinh:da": "\u0DAF",
+ "/sinh:dda": "\u0DA9",
+ "/sinh:ddha": "\u0DAA",
+ "/sinh:dha": "\u0DB0",
+ "/sinh:e": "\u0D91",
+ "/sinh:ee": "\u0D92",
+ "/sinh:eesign": "\u0DDA",
+ "/sinh:esign": "\u0DD9",
+ "/sinh:fa": "\u0DC6",
+ "/sinh:ga": "\u0D9C",
+ "/sinh:gha": "\u0D9D",
+ "/sinh:ha": "\u0DC4",
+ "/sinh:i": "\u0D89",
+ "/sinh:ii": "\u0D8A",
+ "/sinh:iisign": "\u0DD3",
+ "/sinh:isign": "\u0DD2",
+ "/sinh:ja": "\u0DA2",
+ "/sinh:jha": "\u0DA3",
+ "/sinh:jnya": "\u0DA5",
+ "/sinh:ka": "\u0D9A",
+ "/sinh:kha": "\u0D9B",
+ "/sinh:kunddaliya": "\u0DF4",
+ "/sinh:la": "\u0DBD",
+ "/sinh:litheight": "\u0DEE",
+ "/sinh:lithfive": "\u0DEB",
+ "/sinh:lithfour": "\u0DEA",
+ "/sinh:lithnine": "\u0DEF",
+ "/sinh:lithone": "\u0DE7",
+ "/sinh:lithseven": "\u0DED",
+ "/sinh:lithsix": "\u0DEC",
+ "/sinh:liththree": "\u0DE9",
+ "/sinh:lithtwo": "\u0DE8",
+ "/sinh:lithzero": "\u0DE6",
+ "/sinh:lla": "\u0DC5",
+ "/sinh:llvocal": "\u0D90",
+ "/sinh:llvocalsign": "\u0DF3",
+ "/sinh:lvocal": "\u0D8F",
+ "/sinh:lvocalsign": "\u0DDF",
+ "/sinh:ma": "\u0DB8",
+ "/sinh:mba": "\u0DB9",
+ "/sinh:na": "\u0DB1",
+ "/sinh:nda": "\u0DB3",
+ "/sinh:nga": "\u0D9E",
+ "/sinh:nna": "\u0DAB",
+ "/sinh:nndda": "\u0DAC",
+ "/sinh:nnga": "\u0D9F",
+ "/sinh:nya": "\u0DA4",
+ "/sinh:nyja": "\u0DA6",
+ "/sinh:o": "\u0D94",
+ "/sinh:oo": "\u0D95",
+ "/sinh:oosign": "\u0DDD",
+ "/sinh:osign": "\u0DDC",
+ "/sinh:pa": "\u0DB4",
+ "/sinh:pha": "\u0DB5",
+ "/sinh:ra": "\u0DBB",
+ "/sinh:rrvocal": "\u0D8E",
+ "/sinh:rrvocalsign": "\u0DF2",
+ "/sinh:rvocal": "\u0D8D",
+ "/sinh:rvocalsign": "\u0DD8",
+ "/sinh:sa": "\u0DC3",
+ "/sinh:sha": "\u0DC1",
+ "/sinh:ssa": "\u0DC2",
+ "/sinh:ta": "\u0DAD",
+ "/sinh:tha": "\u0DAE",
+ "/sinh:tta": "\u0DA7",
+ "/sinh:ttha": "\u0DA8",
+ "/sinh:u": "\u0D8B",
+ "/sinh:usign": "\u0DD4",
+ "/sinh:uu": "\u0D8C",
+ "/sinh:uusign": "\u0DD6",
+ "/sinh:va": "\u0DC0",
+ "/sinh:virama": "\u0DCA",
+ "/sinh:visarga": "\u0D83",
+ "/sinh:ya": "\u0DBA",
+ "/sinologicaldot": "\uA78F",
+ "/sinsular": "\uA785",
+ "/siosacirclekorean": "\u3274",
+ "/siosaparenkorean": "\u3214",
+ "/sioscieuckorean": "\u317E",
+ "/sioscirclekorean": "\u3266",
+ "/sioskiyeokkorean": "\u317A",
+ "/sioskorean": "\u3145",
+ "/siosnieunkorean": "\u317B",
+ "/siosparenkorean": "\u3206",
+ "/siospieupkorean": "\u317D",
+ "/siostikeutkorean": "\u317C",
+ "/siringusquare": "\u3321",
+ "/six": "\u0036",
+ "/six.inferior": "\u2086",
+ "/six.roman": "\u2165",
+ "/six.romansmall": "\u2175",
+ "/six.superior": "\u2076",
+ "/sixPointedStarMiddleDot": "\u1F52F",
+ "/sixarabic": "\u0666",
+ "/sixbengali": "\u09EC",
+ "/sixcircle": "\u2465",
+ "/sixcircledbl": "\u24FA",
+ "/sixcircleinversesansserif": "\u278F",
+ "/sixcomma": "\u1F107",
+ "/sixdeva": "\u096C",
+ "/sixdotsvertical": "\u2E3D",
+ "/sixfar": "\u06F6",
+ "/sixgujarati": "\u0AEC",
+ "/sixgurmukhi": "\u0A6C",
+ "/sixhackarabic": "\u0666",
+ "/sixhangzhou": "\u3026",
+ "/sixideographiccircled": "\u3285",
+ "/sixideographicparen": "\u3225",
+ "/sixinferior": "\u2086",
+ "/sixlateform.roman": "\u2185",
+ "/sixmonospace": "\uFF16",
+ "/sixoldstyle": "\uF736",
+ "/sixparen": "\u2479",
+ "/sixparenthesized": "\u2479",
+ "/sixperemspace": "\u2006",
+ "/sixperiod": "\u248D",
+ "/sixpersian": "\u06F6",
+ "/sixroman": "\u2175",
+ "/sixsuperior": "\u2076",
+ "/sixteencircle": "\u246F",
+ "/sixteencircleblack": "\u24F0",
+ "/sixteencurrencydenominatorbengali": "\u09F9",
+ "/sixteenparen": "\u2483",
+ "/sixteenparenthesized": "\u2483",
+ "/sixteenperiod": "\u2497",
+ "/sixthai": "\u0E56",
+ "/sixtycirclesquare": "\u324D",
+ "/sixtypsquare": "\u1F1A3",
+ "/sjekomicyr": "\u050D",
+ "/skiAndSkiBoot": "\u1F3BF",
+ "/skier": "\u26F7",
+ "/skull": "\u1F480",
+ "/skullcrossbones": "\u2620",
+ "/slash": "\u002F",
+ "/slashbarfunc": "\u233F",
+ "/slashmonospace": "\uFF0F",
+ "/sled": "\u1F6F7",
+ "/sleeping": "\u1F4A4",
+ "/sleepingAccommodation": "\u1F6CC",
+ "/sleepingFace": "\u1F634",
+ "/sleepyFace": "\u1F62A",
+ "/sleuthOrSpy": "\u1F575",
+ "/sliceOfPizza": "\u1F355",
+ "/slightlyFrowningFace": "\u1F641",
+ "/slightlySmilingFace": "\u1F642",
+ "/slong": "\u017F",
+ "/slongdotaccent": "\u1E9B",
+ "/slope": "\u2333",
+ "/slotMachine": "\u1F3B0",
+ "/smallAirplane": "\u1F6E9",
+ "/smallBlueDiamond": "\u1F539",
+ "/smallOrangeDiamond": "\u1F538",
+ "/smallRedTriangleDOwn": "\u1F53D",
+ "/smallRedTriangleUp": "\u1F53C",
+ "/smile": "\u2323",
+ "/smileface": "\u263A",
+ "/smilingCatFaceWithHeartShapedEyes": "\u1F63B",
+ "/smilingCatFaceWithOpenMouth": "\u1F63A",
+ "/smilingFaceWithHalo": "\u1F607",
+ "/smilingFaceWithHeartShapedEyes": "\u1F60D",
+ "/smilingFaceWithHorns": "\u1F608",
+ "/smilingFaceWithOpenMouth": "\u1F603",
+ "/smilingFaceWithOpenMouthAndColdSweat": "\u1F605",
+ "/smilingFaceWithOpenMouthAndSmilingEyes": "\u1F604",
+ "/smilingFaceWithOpenMouthAndTightlyClosedEyes": "\u1F606",
+ "/smilingFaceWithSmilingEyes": "\u1F60A",
+ "/smilingFaceWithSunglasses": "\u1F60E",
+ "/smilingfaceblack": "\u263B",
+ "/smilingfacewhite": "\u263A",
+ "/smirkingFace": "\u1F60F",
+ "/smll:ampersand": "\uFE60",
+ "/smll:asterisk": "\uFE61",
+ "/smll:backslash": "\uFE68",
+ "/smll:braceleft": "\uFE5B",
+ "/smll:braceright": "\uFE5C",
+ "/smll:colon": "\uFE55",
+ "/smll:comma": "\uFE50",
+ "/smll:dollar": "\uFE69",
+ "/smll:emdash": "\uFE58",
+ "/smll:equal": "\uFE66",
+ "/smll:exclam": "\uFE57",
+ "/smll:greater": "\uFE65",
+ "/smll:hyphen": "\uFE63",
+ "/smll:ideographiccomma": "\uFE51",
+ "/smll:less": "\uFE64",
+ "/smll:numbersign": "\uFE5F",
+ "/smll:parenthesisleft": "\uFE59",
+ "/smll:parenthesisright": "\uFE5A",
+ "/smll:percent": "\uFE6A",
+ "/smll:period": "\uFE52",
+ "/smll:plus": "\uFE62",
+ "/smll:question": "\uFE56",
+ "/smll:semicolon": "\uFE54",
+ "/smll:tortoiseshellbracketleft": "\uFE5D",
+ "/smll:tortoiseshellbracketright": "\uFE5E",
+ "/smoking": "\u1F6AC",
+ "/smonospace": "\uFF53",
+ "/snail": "\u1F40C",
+ "/snake": "\u1F40D",
+ "/snowboarder": "\u1F3C2",
+ "/snowcappedMountain": "\u1F3D4",
+ "/snowman": "\u2603",
+ "/snowmanblack": "\u26C7",
+ "/snowmanoutsnow": "\u26C4",
+ "/sobliquestroke": "\uA7A9",
+ "/soccerball": "\u26BD",
+ "/societyideographiccircled": "\u3293",
+ "/societyideographicparen": "\u3233",
+ "/socirclekatakana": "\u32DE",
+ "/sofPasuq:hb": "\u05C3",
+ "/sofpasuqhebrew": "\u05C3",
+ "/softIceCream": "\u1F366",
+ "/softShellFloppyDisk": "\u1F5AC",
+ "/softcyr": "\u044C",
+ "/softhyphen": "\u00AD",
+ "/softsigncyrillic": "\u044C",
+ "/softwarefunction": "\u2394",
+ "/sohiragana": "\u305D",
+ "/sokatakana": "\u30BD",
+ "/sokatakanahalfwidth": "\uFF7F",
+ "/soliduslongoverlaycmb": "\u0338",
+ "/solidusshortoverlaycmb": "\u0337",
+ "/solidussubsetreversepreceding": "\u27C8",
+ "/solidussupersetpreceding": "\u27C9",
+ "/soonRightwardsArrowAbove": "\u1F51C",
+ "/sorusithai": "\u0E29",
+ "/sosalathai": "\u0E28",
+ "/sosothai": "\u0E0B",
+ "/sossquare": "\u1F198",
+ "/sosuathai": "\u0E2A",
+ "/soundcopyright": "\u2117",
+ "/space": "\u0020",
+ "/spacehackarabic": "\u0020",
+ "/spade": "\u2660",
+ "/spadeblack": "\u2660",
+ "/spadesuitblack": "\u2660",
+ "/spadesuitwhite": "\u2664",
+ "/spadewhite": "\u2664",
+ "/spaghetti": "\u1F35D",
+ "/sparen": "\u24AE",
+ "/sparenthesized": "\u24AE",
+ "/sparklingHeart": "\u1F496",
+ "/speakNoEvilMonkey": "\u1F64A",
+ "/speaker": "\u1F508",
+ "/speakerCancellationStroke": "\u1F507",
+ "/speakerOneSoundWave": "\u1F509",
+ "/speakerThreeSoundWaves": "\u1F50A",
+ "/speakingHeadInSilhouette": "\u1F5E3",
+ "/specialideographiccircled": "\u3295",
+ "/specialideographicparen": "\u3235",
+ "/speechBalloon": "\u1F4AC",
+ "/speedboat": "\u1F6A4",
+ "/spesmilo": "\u20B7",
+ "/sphericalangle": "\u2222",
+ "/spider": "\u1F577",
+ "/spiderWeb": "\u1F578",
+ "/spiralCalendarPad": "\u1F5D3",
+ "/spiralNotePad": "\u1F5D2",
+ "/spiralShell": "\u1F41A",
+ "/splashingSweat": "\u1F4A6",
+ "/sportsMedal": "\u1F3C5",
+ "/spoutingWhale": "\u1F433",
+ "/sppl:tildevertical": "\u2E2F",
+ "/squarebelowcmb": "\u033B",
+ "/squareblack": "\u25A0",
+ "/squarebracketleftvertical": "\uFE47",
+ "/squarebracketrightvertical": "\uFE48",
+ "/squarecap": "\u2293",
+ "/squarecc": "\u33C4",
+ "/squarecm": "\u339D",
+ "/squarecup": "\u2294",
+ "/squareddotoperator": "\u22A1",
+ "/squarediagonalcrosshatchfill": "\u25A9",
+ "/squaredj": "\u1F190",
+ "/squaredkey": "\u26BF",
+ "/squaredminus": "\u229F",
+ "/squaredplus": "\u229E",
+ "/squaredsaltire": "\u26DD",
+ "/squaredtimes": "\u22A0",
+ "/squarefourcorners": "\u26F6",
+ "/squarehalfleftblack": "\u25E7",
+ "/squarehalfrightblack": "\u25E8",
+ "/squarehorizontalfill": "\u25A4",
+ "/squareimage": "\u228F",
+ "/squareimageorequal": "\u2291",
+ "/squareimageornotequal": "\u22E4",
+ "/squarekg": "\u338F",
+ "/squarekm": "\u339E",
+ "/squarekmcapital": "\u33CE",
+ "/squareln": "\u33D1",
+ "/squarelog": "\u33D2",
+ "/squarelowerdiagonalhalfrightblack": "\u25EA",
+ "/squaremediumblack": "\u25FC",
+ "/squaremediumwhite": "\u25FB",
+ "/squaremg": "\u338E",
+ "/squaremil": "\u33D5",
+ "/squaremm": "\u339C",
+ "/squaremsquared": "\u33A1",
+ "/squareoriginal": "\u2290",
+ "/squareoriginalorequal": "\u2292",
+ "/squareoriginalornotequal": "\u22E5",
+ "/squareorthogonalcrosshatchfill": "\u25A6",
+ "/squareraised": "\u2E0B",
+ "/squaresmallblack": "\u25AA",
+ "/squaresmallmediumblack": "\u25FE",
+ "/squaresmallmediumwhite": "\u25FD",
+ "/squaresmallwhite": "\u25AB",
+ "/squareupperdiagonalhalfleftblack": "\u25E9",
+ "/squareupperlefttolowerrightfill": "\u25A7",
+ "/squareupperrighttolowerleftfill": "\u25A8",
+ "/squareverticalfill": "\u25A5",
+ "/squarewhite": "\u25A1",
+ "/squarewhitebisectinglinevertical": "\u25EB",
+ "/squarewhitelowerquadrantleft": "\u25F1",
+ "/squarewhitelowerquadrantright": "\u25F2",
+ "/squarewhiteround": "\u25A2",
+ "/squarewhiteupperquadrantleft": "\u25F0",
+ "/squarewhiteupperquadrantright": "\u25F3",
+ "/squarewhitewithsmallblack": "\u25A3",
+ "/squarewhitewithsquaresmallblack": "\u25A3",
+ "/squishquadfunc": "\u2337",
+ "/srfullwidth": "\u33DB",
+ "/srsquare": "\u33DB",
+ "/ssabengali": "\u09B7",
+ "/ssadeva": "\u0937",
+ "/ssagujarati": "\u0AB7",
+ "/ssangcieuckorean": "\u3149",
+ "/ssanghieuhkorean": "\u3185",
+ "/ssangieungkorean": "\u3180",
+ "/ssangkiyeokkorean": "\u3132",
+ "/ssangnieunkorean": "\u3165",
+ "/ssangpieupkorean": "\u3143",
+ "/ssangsioskorean": "\u3146",
+ "/ssangtikeutkorean": "\u3138",
+ "/ssuperior": "\uF6F2",
+ "/ssupmod": "\u02E2",
+ "/sswashtail": "\u023F",
+ "/stackedcommadbl": "\u2E49",
+ "/stadium": "\u1F3DF",
+ "/staffofaesculapius": "\u2695",
+ "/staffofhermes": "\u269A",
+ "/stampedEnvelope": "\u1F583",
+ "/star": "\u22C6",
+ "/starblack": "\u2605",
+ "/starcrescent": "\u262A",
+ "/stardiaeresisfunc": "\u2363",
+ "/starequals": "\u225B",
+ "/staroperator": "\u22C6",
+ "/staroutlinedwhite": "\u269D",
+ "/starwhite": "\u2606",
+ "/station": "\u1F689",
+ "/statueOfLiberty": "\u1F5FD",
+ "/steamLocomotive": "\u1F682",
+ "/steamingBowl": "\u1F35C",
+ "/stenographicfullstop": "\u2E3C",
+ "/sterling": "\u00A3",
+ "/sterlingmonospace": "\uFFE1",
+ "/stigma": "\u03DB",
+ "/stiletildefunc": "\u236D",
+ "/stockChart": "\u1F5E0",
+ "/stockideographiccircled": "\u3291",
+ "/stockideographicparen": "\u3231",
+ "/stopabove": "\u06EB",
+ "/stopbelow": "\u06EA",
+ "/straightRuler": "\u1F4CF",
+ "/straightness": "\u23E4",
+ "/strawberry": "\u1F353",
+ "/stresslowtonemod": "\uA721",
+ "/stresstonemod": "\uA720",
+ "/strictlyequivalent": "\u2263",
+ "/strokelongoverlaycmb": "\u0336",
+ "/strokeshortoverlaycmb": "\u0335",
+ "/studioMicrophone": "\u1F399",
+ "/studyideographiccircled": "\u32AB",
+ "/studyideographicparen": "\u323B",
+ "/stupa": "\u1F6D3",
+ "/subscriptalef": "\u0656",
+ "/subset": "\u2282",
+ "/subsetdbl": "\u22D0",
+ "/subsetnotequal": "\u228A",
+ "/subsetorequal": "\u2286",
+ "/succeeds": "\u227B",
+ "/succeedsbutnotequivalent": "\u22E9",
+ "/succeedsorequal": "\u227D",
+ "/succeedsorequivalent": "\u227F",
+ "/succeedsunderrelation": "\u22B1",
+ "/suchthat": "\u220B",
+ "/sucirclekatakana": "\u32DC",
+ "/suhiragana": "\u3059",
+ "/suitableideographiccircled": "\u329C",
+ "/sukatakana": "\u30B9",
+ "/sukatakanahalfwidth": "\uFF7D",
+ "/sukumendutvowel": "\uA9B9",
+ "/sukunIsol": "\uFE7E",
+ "/sukunMedi": "\uFE7F",
+ "/sukunarabic": "\u0652",
+ "/sukuvowel": "\uA9B8",
+ "/summation": "\u2211",
+ "/summationbottom": "\u23B3",
+ "/summationdblstruck": "\u2140",
+ "/summationtop": "\u23B2",
+ "/sun": "\u263C",
+ "/sunFace": "\u1F31E",
+ "/sunbehindcloud": "\u26C5",
+ "/sunflower": "\u1F33B",
+ "/sunideographiccircled": "\u3290",
+ "/sunideographicparen": "\u3230",
+ "/sunraysblack": "\u2600",
+ "/sunrayswhite": "\u263C",
+ "/sunrise": "\u1F305",
+ "/sunriseOverMountains": "\u1F304",
+ "/sunsetOverBuildings": "\u1F307",
+ "/superset": "\u2283",
+ "/supersetnotequal": "\u228B",
+ "/supersetorequal": "\u2287",
+ "/superviseideographiccircled": "\u32AC",
+ "/superviseideographicparen": "\u323C",
+ "/surfer": "\u1F3C4",
+ "/sushi": "\u1F363",
+ "/suspensionRailway": "\u1F69F",
+ "/suspensiondbl": "\u2E44",
+ "/svfullwidth": "\u33DC",
+ "/svsquare": "\u33DC",
+ "/swatchtop": "\u23F1",
+ "/swimmer": "\u1F3CA",
+ "/swungdash": "\u2053",
+ "/symbolabovethreedotsabove": "\uFBB6",
+ "/symbolbelowthreedotsabove": "\uFBB7",
+ "/symboldotabove": "\uFBB2",
+ "/symboldotbelow": "\uFBB3",
+ "/symboldoubleverticalbarbelow": "\uFBBC",
+ "/symbolfourdotsabove": "\uFBBA",
+ "/symbolfourdotsbelow": "\uFBBB",
+ "/symbolpointingabovedownthreedotsabove": "\uFBB8",
+ "/symbolpointingbelowdownthreedotsabove": "\uFBB9",
+ "/symbolring": "\uFBBF",
+ "/symboltahabovesmall": "\uFBC0",
+ "/symboltahbelowsmall": "\uFBC1",
+ "/symboltwodotsabove": "\uFBB4",
+ "/symboltwodotsbelow": "\uFBB5",
+ "/symboltwodotsverticallyabove": "\uFBBD",
+ "/symboltwodotsverticallybelow": "\uFBBE",
+ "/symmetry": "\u232F",
+ "/synagogue": "\u1F54D",
+ "/syouwaerasquare": "\u337C",
+ "/syringe": "\u1F489",
+ "/t": "\u0074",
+ "/t-shirt": "\u1F455",
+ "/t.inferior": "\u209C",
+ "/tabengali": "\u09A4",
+ "/tableTennisPaddleAndBall": "\u1F3D3",
+ "/tacirclekatakana": "\u32DF",
+ "/tackcircleaboveup": "\u27DF",
+ "/tackdiaeresisupfunc": "\u2361",
+ "/tackdown": "\u22A4",
+ "/tackdownmod": "\u02D5",
+ "/tackjotdownfunc": "\u234E",
+ "/tackjotupfunc": "\u2355",
+ "/tackleft": "\u22A3",
+ "/tackleftright": "\u27DB",
+ "/tackoverbarupfunc": "\u2351",
+ "/tackright": "\u22A2",
+ "/tackunderlinedownfunc": "\u234A",
+ "/tackup": "\u22A5",
+ "/tackupmod": "\u02D4",
+ "/taco": "\u1F32E",
+ "/tadeva": "\u0924",
+ "/tagujarati": "\u0AA4",
+ "/tagurmukhi": "\u0A24",
+ "/tah": "\u0637",
+ "/tah.fina": "\uFEC2",
+ "/tah.init": "\uFEC3",
+ "/tah.init_alefmaksura.fina": "\uFCF5",
+ "/tah.init_hah.fina": "\uFC26",
+ "/tah.init_hah.medi": "\uFCB8",
+ "/tah.init_meem.fina": "\uFC27",
+ "/tah.init_meem.medi": "\uFD33",
+ "/tah.init_meem.medi_hah.medi": "\uFD72",
+ "/tah.init_meem.medi_meem.medi": "\uFD73",
+ "/tah.init_yeh.fina": "\uFCF6",
+ "/tah.isol": "\uFEC1",
+ "/tah.medi": "\uFEC4",
+ "/tah.medi_alefmaksura.fina": "\uFD11",
+ "/tah.medi_meem.medi": "\uFD3A",
+ "/tah.medi_meem.medi_hah.fina": "\uFD71",
+ "/tah.medi_meem.medi_yeh.fina": "\uFD74",
+ "/tah.medi_yeh.fina": "\uFD12",
+ "/tahabove": "\u0615",
+ "/taharabic": "\u0637",
+ "/tahfinalarabic": "\uFEC2",
+ "/tahinitialarabic": "\uFEC3",
+ "/tahiragana": "\u305F",
+ "/tahmedialarabic": "\uFEC4",
+ "/tahthreedotsabove": "\u069F",
+ "/taisyouerasquare": "\u337D",
+ "/takatakana": "\u30BF",
+ "/takatakanahalfwidth": "\uFF80",
+ "/takhallus": "\u0614",
+ "/talingvowel": "\uA9BA",
+ "/taml:a": "\u0B85",
+ "/taml:aa": "\u0B86",
+ "/taml:aasign": "\u0BBE",
+ "/taml:ai": "\u0B90",
+ "/taml:aisign": "\u0BC8",
+ "/taml:anusvarasign": "\u0B82",
+ "/taml:asabovesign": "\u0BF8",
+ "/taml:au": "\u0B94",
+ "/taml:aulengthmark": "\u0BD7",
+ "/taml:ausign": "\u0BCC",
+ "/taml:ca": "\u0B9A",
+ "/taml:creditsign": "\u0BF7",
+ "/taml:daysign": "\u0BF3",
+ "/taml:debitsign": "\u0BF6",
+ "/taml:e": "\u0B8E",
+ "/taml:ee": "\u0B8F",
+ "/taml:eesign": "\u0BC7",
+ "/taml:eight": "\u0BEE",
+ "/taml:esign": "\u0BC6",
+ "/taml:five": "\u0BEB",
+ "/taml:four": "\u0BEA",
+ "/taml:ha": "\u0BB9",
+ "/taml:i": "\u0B87",
+ "/taml:ii": "\u0B88",
+ "/taml:iisign": "\u0BC0",
+ "/taml:isign": "\u0BBF",
+ "/taml:ja": "\u0B9C",
+ "/taml:ka": "\u0B95",
+ "/taml:la": "\u0BB2",
+ "/taml:lla": "\u0BB3",
+ "/taml:llla": "\u0BB4",
+ "/taml:ma": "\u0BAE",
+ "/taml:monthsign": "\u0BF4",
+ "/taml:na": "\u0BA8",
+ "/taml:nga": "\u0B99",
+ "/taml:nine": "\u0BEF",
+ "/taml:nna": "\u0BA3",
+ "/taml:nnna": "\u0BA9",
+ "/taml:nya": "\u0B9E",
+ "/taml:o": "\u0B92",
+ "/taml:om": "\u0BD0",
+ "/taml:one": "\u0BE7",
+ "/taml:onehundred": "\u0BF1",
+ "/taml:onethousand": "\u0BF2",
+ "/taml:oo": "\u0B93",
+ "/taml:oosign": "\u0BCB",
+ "/taml:osign": "\u0BCA",
+ "/taml:pa": "\u0BAA",
+ "/taml:ra": "\u0BB0",
+ "/taml:rra": "\u0BB1",
+ "/taml:rupeesign": "\u0BF9",
+ "/taml:sa": "\u0BB8",
+ "/taml:seven": "\u0BED",
+ "/taml:sha": "\u0BB6",
+ "/taml:sign": "\u0BFA",
+ "/taml:six": "\u0BEC",
+ "/taml:ssa": "\u0BB7",
+ "/taml:ta": "\u0BA4",
+ "/taml:ten": "\u0BF0",
+ "/taml:three": "\u0BE9",
+ "/taml:tta": "\u0B9F",
+ "/taml:two": "\u0BE8",
+ "/taml:u": "\u0B89",
+ "/taml:usign": "\u0BC1",
+ "/taml:uu": "\u0B8A",
+ "/taml:uusign": "\u0BC2",
+ "/taml:va": "\u0BB5",
+ "/taml:viramasign": "\u0BCD",
+ "/taml:visargasign": "\u0B83",
+ "/taml:ya": "\u0BAF",
+ "/taml:yearsign": "\u0BF5",
+ "/taml:zero": "\u0BE6",
+ "/tamurda": "\uA9A1",
+ "/tanabataTree": "\u1F38B",
+ "/tangerine": "\u1F34A",
+ "/tapeCartridge": "\u1F5AD",
+ "/tarungvowel": "\uA9B4",
+ "/tatweelFathatanAbove": "\uFE71",
+ "/tatweelarabic": "\u0640",
+ "/tau": "\u03C4",
+ "/taurus": "\u2649",
+ "/tav": "\u05EA",
+ "/tav:hb": "\u05EA",
+ "/tavdages": "\uFB4A",
+ "/tavdagesh": "\uFB4A",
+ "/tavdageshhebrew": "\uFB4A",
+ "/tavhebrew": "\u05EA",
+ "/tavwide:hb": "\uFB28",
+ "/tavwithdagesh:hb": "\uFB4A",
+ "/taxi": "\u1F695",
+ "/tbar": "\u0167",
+ "/tbopomofo": "\u310A",
+ "/tcaron": "\u0165",
+ "/tccurl": "\u02A8",
+ "/tcedilla": "\u0163",
+ "/tcheh": "\u0686",
+ "/tcheh.fina": "\uFB7B",
+ "/tcheh.init": "\uFB7C",
+ "/tcheh.isol": "\uFB7A",
+ "/tcheh.medi": "\uFB7D",
+ "/tcheharabic": "\u0686",
+ "/tchehdotabove": "\u06BF",
+ "/tcheheh": "\u0687",
+ "/tcheheh.fina": "\uFB7F",
+ "/tcheheh.init": "\uFB80",
+ "/tcheheh.isol": "\uFB7E",
+ "/tcheheh.medi": "\uFB81",
+ "/tchehfinalarabic": "\uFB7B",
+ "/tchehinitialarabic": "\uFB7C",
+ "/tchehmedialarabic": "\uFB7D",
+ "/tchehmeeminitialarabic": "\uFB7C",
+ "/tcircle": "\u24E3",
+ "/tcircumflexbelow": "\u1E71",
+ "/tcommaaccent": "\u0163",
+ "/tcurl": "\u0236",
+ "/tdieresis": "\u1E97",
+ "/tdot": "\u1E6B",
+ "/tdotaccent": "\u1E6B",
+ "/tdotbelow": "\u1E6D",
+ "/teacupOutHandle": "\u1F375",
+ "/tear-offCalendar": "\u1F4C6",
+ "/tecirclekatakana": "\u32E2",
+ "/tecyr": "\u0442",
+ "/tecyrillic": "\u0442",
+ "/tedescendercyrillic": "\u04AD",
+ "/teh": "\u062A",
+ "/teh.fina": "\uFE96",
+ "/teh.init": "\uFE97",
+ "/teh.init_alefmaksura.fina": "\uFC0F",
+ "/teh.init_hah.fina": "\uFC0C",
+ "/teh.init_hah.medi": "\uFCA2",
+ "/teh.init_hah.medi_jeem.medi": "\uFD52",
+ "/teh.init_hah.medi_meem.medi": "\uFD53",
+ "/teh.init_heh.medi": "\uFCA5",
+ "/teh.init_jeem.fina": "\uFC0B",
+ "/teh.init_jeem.medi": "\uFCA1",
+ "/teh.init_jeem.medi_meem.medi": "\uFD50",
+ "/teh.init_khah.fina": "\uFC0D",
+ "/teh.init_khah.medi": "\uFCA3",
+ "/teh.init_khah.medi_meem.medi": "\uFD54",
+ "/teh.init_meem.fina": "\uFC0E",
+ "/teh.init_meem.medi": "\uFCA4",
+ "/teh.init_meem.medi_hah.medi": "\uFD56",
+ "/teh.init_meem.medi_jeem.medi": "\uFD55",
+ "/teh.init_meem.medi_khah.medi": "\uFD57",
+ "/teh.init_yeh.fina": "\uFC10",
+ "/teh.isol": "\uFE95",
+ "/teh.medi": "\uFE98",
+ "/teh.medi_alefmaksura.fina": "\uFC74",
+ "/teh.medi_hah.medi_jeem.fina": "\uFD51",
+ "/teh.medi_heh.medi": "\uFCE4",
+ "/teh.medi_jeem.medi_alefmaksura.fina": "\uFDA0",
+ "/teh.medi_jeem.medi_yeh.fina": "\uFD9F",
+ "/teh.medi_khah.medi_alefmaksura.fina": "\uFDA2",
+ "/teh.medi_khah.medi_yeh.fina": "\uFDA1",
+ "/teh.medi_meem.fina": "\uFC72",
+ "/teh.medi_meem.medi": "\uFCE3",
+ "/teh.medi_meem.medi_alefmaksura.fina": "\uFDA4",
+ "/teh.medi_meem.medi_yeh.fina": "\uFDA3",
+ "/teh.medi_noon.fina": "\uFC73",
+ "/teh.medi_reh.fina": "\uFC70",
+ "/teh.medi_yeh.fina": "\uFC75",
+ "/teh.medi_zain.fina": "\uFC71",
+ "/teharabic": "\u062A",
+ "/tehdownthreedotsabove": "\u067D",
+ "/teheh": "\u067F",
+ "/teheh.fina": "\uFB63",
+ "/teheh.init": "\uFB64",
+ "/teheh.isol": "\uFB62",
+ "/teheh.medi": "\uFB65",
+ "/tehfinalarabic": "\uFE96",
+ "/tehhahinitialarabic": "\uFCA2",
+ "/tehhahisolatedarabic": "\uFC0C",
+ "/tehinitialarabic": "\uFE97",
+ "/tehiragana": "\u3066",
+ "/tehjeeminitialarabic": "\uFCA1",
+ "/tehjeemisolatedarabic": "\uFC0B",
+ "/tehmarbuta": "\u0629",
+ "/tehmarbuta.fina": "\uFE94",
+ "/tehmarbuta.isol": "\uFE93",
+ "/tehmarbutaarabic": "\u0629",
+ "/tehmarbutafinalarabic": "\uFE94",
+ "/tehmarbutagoal": "\u06C3",
+ "/tehmedialarabic": "\uFE98",
+ "/tehmeeminitialarabic": "\uFCA4",
+ "/tehmeemisolatedarabic": "\uFC0E",
+ "/tehnoonfinalarabic": "\uFC73",
+ "/tehring": "\u067C",
+ "/tekatakana": "\u30C6",
+ "/tekatakanahalfwidth": "\uFF83",
+ "/telephone": "\u2121",
+ "/telephoneOnTopOfModem": "\u1F580",
+ "/telephoneReceiver": "\u1F4DE",
+ "/telephoneReceiverPage": "\u1F57C",
+ "/telephoneblack": "\u260E",
+ "/telephonerecorder": "\u2315",
+ "/telephonewhite": "\u260F",
+ "/telescope": "\u1F52D",
+ "/television": "\u1F4FA",
+ "/telishaGedolah:hb": "\u05A0",
+ "/telishaQetannah:hb": "\u05A9",
+ "/telishagedolahebrew": "\u05A0",
+ "/telishaqetanahebrew": "\u05A9",
+ "/telu:a": "\u0C05",
+ "/telu:aa": "\u0C06",
+ "/telu:aasign": "\u0C3E",
+ "/telu:ai": "\u0C10",
+ "/telu:ailengthmark": "\u0C56",
+ "/telu:aisign": "\u0C48",
+ "/telu:anusvarasign": "\u0C02",
+ "/telu:au": "\u0C14",
+ "/telu:ausign": "\u0C4C",
+ "/telu:avagrahasign": "\u0C3D",
+ "/telu:ba": "\u0C2C",
+ "/telu:bha": "\u0C2D",
+ "/telu:bindusigncandra": "\u0C01",
+ "/telu:ca": "\u0C1A",
+ "/telu:cha": "\u0C1B",
+ "/telu:combiningbinduabovesigncandra": "\u0C00",
+ "/telu:da": "\u0C26",
+ "/telu:dda": "\u0C21",
+ "/telu:ddha": "\u0C22",
+ "/telu:dha": "\u0C27",
+ "/telu:dza": "\u0C59",
+ "/telu:e": "\u0C0E",
+ "/telu:ee": "\u0C0F",
+ "/telu:eesign": "\u0C47",
+ "/telu:eight": "\u0C6E",
+ "/telu:esign": "\u0C46",
+ "/telu:five": "\u0C6B",
+ "/telu:four": "\u0C6A",
+ "/telu:fractiononeforevenpowersoffour": "\u0C7C",
+ "/telu:fractiononeforoddpowersoffour": "\u0C79",
+ "/telu:fractionthreeforevenpowersoffour": "\u0C7E",
+ "/telu:fractionthreeforoddpowersoffour": "\u0C7B",
+ "/telu:fractiontwoforevenpowersoffour": "\u0C7D",
+ "/telu:fractiontwoforoddpowersoffour": "\u0C7A",
+ "/telu:fractionzeroforoddpowersoffour": "\u0C78",
+ "/telu:ga": "\u0C17",
+ "/telu:gha": "\u0C18",
+ "/telu:ha": "\u0C39",
+ "/telu:i": "\u0C07",
+ "/telu:ii": "\u0C08",
+ "/telu:iisign": "\u0C40",
+ "/telu:isign": "\u0C3F",
+ "/telu:ja": "\u0C1C",
+ "/telu:jha": "\u0C1D",
+ "/telu:ka": "\u0C15",
+ "/telu:kha": "\u0C16",
+ "/telu:la": "\u0C32",
+ "/telu:lengthmark": "\u0C55",
+ "/telu:lla": "\u0C33",
+ "/telu:llla": "\u0C34",
+ "/telu:llsignvocal": "\u0C63",
+ "/telu:llvocal": "\u0C61",
+ "/telu:lsignvocal": "\u0C62",
+ "/telu:lvocal": "\u0C0C",
+ "/telu:ma": "\u0C2E",
+ "/telu:na": "\u0C28",
+ "/telu:nga": "\u0C19",
+ "/telu:nine": "\u0C6F",
+ "/telu:nna": "\u0C23",
+ "/telu:nya": "\u0C1E",
+ "/telu:o": "\u0C12",
+ "/telu:one": "\u0C67",
+ "/telu:oo": "\u0C13",
+ "/telu:oosign": "\u0C4B",
+ "/telu:osign": "\u0C4A",
+ "/telu:pa": "\u0C2A",
+ "/telu:pha": "\u0C2B",
+ "/telu:ra": "\u0C30",
+ "/telu:rra": "\u0C31",
+ "/telu:rrra": "\u0C5A",
+ "/telu:rrsignvocal": "\u0C44",
+ "/telu:rrvocal": "\u0C60",
+ "/telu:rsignvocal": "\u0C43",
+ "/telu:rvocal": "\u0C0B",
+ "/telu:sa": "\u0C38",
+ "/telu:seven": "\u0C6D",
+ "/telu:sha": "\u0C36",
+ "/telu:six": "\u0C6C",
+ "/telu:ssa": "\u0C37",
+ "/telu:ta": "\u0C24",
+ "/telu:tha": "\u0C25",
+ "/telu:three": "\u0C69",
+ "/telu:tsa": "\u0C58",
+ "/telu:tta": "\u0C1F",
+ "/telu:ttha": "\u0C20",
+ "/telu:tuumusign": "\u0C7F",
+ "/telu:two": "\u0C68",
+ "/telu:u": "\u0C09",
+ "/telu:usign": "\u0C41",
+ "/telu:uu": "\u0C0A",
+ "/telu:uusign": "\u0C42",
+ "/telu:va": "\u0C35",
+ "/telu:viramasign": "\u0C4D",
+ "/telu:visargasign": "\u0C03",
+ "/telu:ya": "\u0C2F",
+ "/telu:zero": "\u0C66",
+ "/ten.roman": "\u2169",
+ "/ten.romansmall": "\u2179",
+ "/tencircle": "\u2469",
+ "/tencircledbl": "\u24FE",
+ "/tencirclesquare": "\u3248",
+ "/tenge": "\u20B8",
+ "/tenhangzhou": "\u3038",
+ "/tenideographiccircled": "\u3289",
+ "/tenideographicparen": "\u3229",
+ "/tennisRacquetAndBall": "\u1F3BE",
+ "/tenparen": "\u247D",
+ "/tenparenthesized": "\u247D",
+ "/tenperiod": "\u2491",
+ "/tenroman": "\u2179",
+ "/tent": "\u26FA",
+ "/tenthousand.roman": "\u2182",
+ "/tesh": "\u02A7",
+ "/tet": "\u05D8",
+ "/tet:hb": "\u05D8",
+ "/tetailcyr": "\u04AD",
+ "/tetdagesh": "\uFB38",
+ "/tetdageshhebrew": "\uFB38",
+ "/tethebrew": "\u05D8",
+ "/tetrasememetrical": "\u23D8",
+ "/tetsecyr": "\u04B5",
+ "/tetsecyrillic": "\u04B5",
+ "/tetwithdagesh:hb": "\uFB38",
+ "/tevir:hb": "\u059B",
+ "/tevirhebrew": "\u059B",
+ "/tevirlefthebrew": "\u059B",
+ "/thabengali": "\u09A5",
+ "/thadeva": "\u0925",
+ "/thagujarati": "\u0AA5",
+ "/thagurmukhi": "\u0A25",
+ "/thai:angkhankhu": "\u0E5A",
+ "/thai:baht": "\u0E3F",
+ "/thai:bobaimai": "\u0E1A",
+ "/thai:chochan": "\u0E08",
+ "/thai:chochang": "\u0E0A",
+ "/thai:choching": "\u0E09",
+ "/thai:chochoe": "\u0E0C",
+ "/thai:dochada": "\u0E0E",
+ "/thai:dodek": "\u0E14",
+ "/thai:eight": "\u0E58",
+ "/thai:five": "\u0E55",
+ "/thai:fofa": "\u0E1D",
+ "/thai:fofan": "\u0E1F",
+ "/thai:fongman": "\u0E4F",
+ "/thai:four": "\u0E54",
+ "/thai:hohip": "\u0E2B",
+ "/thai:honokhuk": "\u0E2E",
+ "/thai:khokhai": "\u0E02",
+ "/thai:khokhon": "\u0E05",
+ "/thai:khokhuat": "\u0E03",
+ "/thai:khokhwai": "\u0E04",
+ "/thai:khomut": "\u0E5B",
+ "/thai:khorakhang": "\u0E06",
+ "/thai:kokai": "\u0E01",
+ "/thai:lakkhangyao": "\u0E45",
+ "/thai:lochula": "\u0E2C",
+ "/thai:loling": "\u0E25",
+ "/thai:lu": "\u0E26",
+ "/thai:maichattawa": "\u0E4B",
+ "/thai:maiek": "\u0E48",
+ "/thai:maihan-akat": "\u0E31",
+ "/thai:maitaikhu": "\u0E47",
+ "/thai:maitho": "\u0E49",
+ "/thai:maitri": "\u0E4A",
+ "/thai:maiyamok": "\u0E46",
+ "/thai:moma": "\u0E21",
+ "/thai:ngongu": "\u0E07",
+ "/thai:nikhahit": "\u0E4D",
+ "/thai:nine": "\u0E59",
+ "/thai:nonen": "\u0E13",
+ "/thai:nonu": "\u0E19",
+ "/thai:oang": "\u0E2D",
+ "/thai:one": "\u0E51",
+ "/thai:paiyannoi": "\u0E2F",
+ "/thai:phinthu": "\u0E3A",
+ "/thai:phophan": "\u0E1E",
+ "/thai:phophung": "\u0E1C",
+ "/thai:phosamphao": "\u0E20",
+ "/thai:popla": "\u0E1B",
+ "/thai:rorua": "\u0E23",
+ "/thai:ru": "\u0E24",
+ "/thai:saraa": "\u0E30",
+ "/thai:saraaa": "\u0E32",
+ "/thai:saraae": "\u0E41",
+ "/thai:saraaimaimalai": "\u0E44",
+ "/thai:saraaimaimuan": "\u0E43",
+ "/thai:saraam": "\u0E33",
+ "/thai:sarae": "\u0E40",
+ "/thai:sarai": "\u0E34",
+ "/thai:saraii": "\u0E35",
+ "/thai:sarao": "\u0E42",
+ "/thai:sarau": "\u0E38",
+ "/thai:saraue": "\u0E36",
+ "/thai:sarauee": "\u0E37",
+ "/thai:sarauu": "\u0E39",
+ "/thai:seven": "\u0E57",
+ "/thai:six": "\u0E56",
+ "/thai:sorusi": "\u0E29",
+ "/thai:sosala": "\u0E28",
+ "/thai:soso": "\u0E0B",
+ "/thai:sosua": "\u0E2A",
+ "/thai:thanthakhat": "\u0E4C",
+ "/thai:thonangmontho": "\u0E11",
+ "/thai:thophuthao": "\u0E12",
+ "/thai:thothahan": "\u0E17",
+ "/thai:thothan": "\u0E10",
+ "/thai:thothong": "\u0E18",
+ "/thai:thothung": "\u0E16",
+ "/thai:three": "\u0E53",
+ "/thai:topatak": "\u0E0F",
+ "/thai:totao": "\u0E15",
+ "/thai:two": "\u0E52",
+ "/thai:wowaen": "\u0E27",
+ "/thai:yamakkan": "\u0E4E",
+ "/thai:yoyak": "\u0E22",
+ "/thai:yoying": "\u0E0D",
+ "/thai:zero": "\u0E50",
+ "/thal": "\u0630",
+ "/thal.fina": "\uFEAC",
+ "/thal.init_superscriptalef.fina": "\uFC5B",
+ "/thal.isol": "\uFEAB",
+ "/thalarabic": "\u0630",
+ "/thalfinalarabic": "\uFEAC",
+ "/thanthakhatlowleftthai": "\uF898",
+ "/thanthakhatlowrightthai": "\uF897",
+ "/thanthakhatthai": "\u0E4C",
+ "/thanthakhatupperleftthai": "\uF896",
+ "/theh": "\u062B",
+ "/theh.fina": "\uFE9A",
+ "/theh.init": "\uFE9B",
+ "/theh.init_alefmaksura.fina": "\uFC13",
+ "/theh.init_jeem.fina": "\uFC11",
+ "/theh.init_meem.fina": "\uFC12",
+ "/theh.init_meem.medi": "\uFCA6",
+ "/theh.init_yeh.fina": "\uFC14",
+ "/theh.isol": "\uFE99",
+ "/theh.medi": "\uFE9C",
+ "/theh.medi_alefmaksura.fina": "\uFC7A",
+ "/theh.medi_heh.medi": "\uFCE6",
+ "/theh.medi_meem.fina": "\uFC78",
+ "/theh.medi_meem.medi": "\uFCE5",
+ "/theh.medi_noon.fina": "\uFC79",
+ "/theh.medi_reh.fina": "\uFC76",
+ "/theh.medi_yeh.fina": "\uFC7B",
+ "/theh.medi_zain.fina": "\uFC77",
+ "/theharabic": "\u062B",
+ "/thehfinalarabic": "\uFE9A",
+ "/thehinitialarabic": "\uFE9B",
+ "/thehmedialarabic": "\uFE9C",
+ "/thereexists": "\u2203",
+ "/therefore": "\u2234",
+ "/thermometer": "\u1F321",
+ "/theta": "\u03B8",
+ "/theta.math": "\u03D1",
+ "/theta1": "\u03D1",
+ "/thetasymbolgreek": "\u03D1",
+ "/thieuthacirclekorean": "\u3279",
+ "/thieuthaparenkorean": "\u3219",
+ "/thieuthcirclekorean": "\u326B",
+ "/thieuthkorean": "\u314C",
+ "/thieuthparenkorean": "\u320B",
+ "/thinspace": "\u2009",
+ "/thirteencircle": "\u246C",
+ "/thirteencircleblack": "\u24ED",
+ "/thirteenparen": "\u2480",
+ "/thirteenparenthesized": "\u2480",
+ "/thirteenperiod": "\u2494",
+ "/thirtycircle": "\u325A",
+ "/thirtycirclesquare": "\u324A",
+ "/thirtyeightcircle": "\u32B3",
+ "/thirtyfivecircle": "\u325F",
+ "/thirtyfourcircle": "\u325E",
+ "/thirtyhangzhou": "\u303A",
+ "/thirtyninecircle": "\u32B4",
+ "/thirtyonecircle": "\u325B",
+ "/thirtysevencircle": "\u32B2",
+ "/thirtysixcircle": "\u32B1",
+ "/thirtythreecircle": "\u325D",
+ "/thirtytwocircle": "\u325C",
+ "/thonangmonthothai": "\u0E11",
+ "/thook": "\u01AD",
+ "/thophuthaothai": "\u0E12",
+ "/thorn": "\u00FE",
+ "/thornstroke": "\uA765",
+ "/thornstrokedescender": "\uA767",
+ "/thothahanthai": "\u0E17",
+ "/thothanthai": "\u0E10",
+ "/thothongthai": "\u0E18",
+ "/thothungthai": "\u0E16",
+ "/thoughtBalloon": "\u1F4AD",
+ "/thousandcyrillic": "\u0482",
+ "/thousandscyr": "\u0482",
+ "/thousandsseparator": "\u066C",
+ "/thousandsseparatorarabic": "\u066C",
+ "/thousandsseparatorpersian": "\u066C",
+ "/three": "\u0033",
+ "/three.inferior": "\u2083",
+ "/three.roman": "\u2162",
+ "/three.romansmall": "\u2172",
+ "/threeButtonMouse": "\u1F5B1",
+ "/threeNetworkedComputers": "\u1F5A7",
+ "/threeRaysAbove": "\u1F5E4",
+ "/threeRaysBelow": "\u1F5E5",
+ "/threeRaysLeft": "\u1F5E6",
+ "/threeRaysRight": "\u1F5E7",
+ "/threeSpeechBubbles": "\u1F5EB",
+ "/threearabic": "\u0663",
+ "/threebengali": "\u09E9",
+ "/threecircle": "\u2462",
+ "/threecircledbl": "\u24F7",
+ "/threecircleinversesansserif": "\u278C",
+ "/threecomma": "\u1F104",
+ "/threedeva": "\u0969",
+ "/threedimensionalangle": "\u27C0",
+ "/threedotpunctuation": "\u2056",
+ "/threedotsaboveabove": "\u06DB",
+ "/threedsquare": "\u1F19B",
+ "/threeeighths": "\u215C",
+ "/threefar": "\u06F3",
+ "/threefifths": "\u2157",
+ "/threegujarati": "\u0AE9",
+ "/threegurmukhi": "\u0A69",
+ "/threehackarabic": "\u0663",
+ "/threehangzhou": "\u3023",
+ "/threeideographiccircled": "\u3282",
+ "/threeideographicparen": "\u3222",
+ "/threeinferior": "\u2083",
+ "/threelinesconvergingleft": "\u269F",
+ "/threelinesconvergingright": "\u269E",
+ "/threemonospace": "\uFF13",
+ "/threenumeratorbengali": "\u09F6",
+ "/threeoldstyle": "\uF733",
+ "/threeparen": "\u2476",
+ "/threeparenthesized": "\u2476",
+ "/threeperemspace": "\u2004",
+ "/threeperiod": "\u248A",
+ "/threepersian": "\u06F3",
+ "/threequarters": "\u00BE",
+ "/threequartersemdash": "\uF6DE",
+ "/threerightarrows": "\u21F6",
+ "/threeroman": "\u2172",
+ "/threesuperior": "\u00B3",
+ "/threethai": "\u0E53",
+ "/thumbsDownSign": "\u1F44E",
+ "/thumbsUpSign": "\u1F44D",
+ "/thundercloudrain": "\u26C8",
+ "/thunderstorm": "\u2608",
+ "/thzfullwidth": "\u3394",
+ "/thzsquare": "\u3394",
+ "/tibt:AA": "\u0F60",
+ "/tibt:a": "\u0F68",
+ "/tibt:aavowelsign": "\u0F71",
+ "/tibt:angkhanggyasmark": "\u0F3D",
+ "/tibt:angkhanggyonmark": "\u0F3C",
+ "/tibt:astrologicalkhyudpasign": "\u0F18",
+ "/tibt:astrologicalsdongtshugssign": "\u0F19",
+ "/tibt:astrologicalsgragcancharrtagssign": "\u0F17",
+ "/tibt:asubjoined": "\u0FB8",
+ "/tibt:ba": "\u0F56",
+ "/tibt:basubjoined": "\u0FA6",
+ "/tibt:bha": "\u0F57",
+ "/tibt:bhasubjoined": "\u0FA7",
+ "/tibt:bkashogyigmgomark": "\u0F0A",
+ "/tibt:brdarnyingyigmgomdunmainitialmark": "\u0FD3",
+ "/tibt:brdarnyingyigmgosgabmaclosingmark": "\u0FD4",
+ "/tibt:bsdusrtagsmark": "\u0F34",
+ "/tibt:bskashoggimgorgyanmark": "\u0FD0",
+ "/tibt:bskuryigmgomark": "\u0F09",
+ "/tibt:ca": "\u0F45",
+ "/tibt:cangteucantillationsign": "\u0FC2",
+ "/tibt:caretdzudrtagsbzhimigcanmark": "\u0F36",
+ "/tibt:caretdzudrtagsmelongcanmark": "\u0F13",
+ "/tibt:caretyigmgophurshadmamark": "\u0F06",
+ "/tibt:casubjoined": "\u0F95",
+ "/tibt:cha": "\u0F46",
+ "/tibt:chadrtagslogotypesign": "\u0F15",
+ "/tibt:chasubjoined": "\u0F96",
+ "/tibt:chemgomark": "\u0F38",
+ "/tibt:da": "\u0F51",
+ "/tibt:dasubjoined": "\u0FA1",
+ "/tibt:dda": "\u0F4C",
+ "/tibt:ddasubjoined": "\u0F9C",
+ "/tibt:ddha": "\u0F4D",
+ "/tibt:ddhasubjoined": "\u0F9D",
+ "/tibt:delimitertshegbstarmark": "\u0F0C",
+ "/tibt:dha": "\u0F52",
+ "/tibt:dhasubjoined": "\u0FA2",
+ "/tibt:drilbusymbol": "\u0FC4",
+ "/tibt:dza": "\u0F5B",
+ "/tibt:dzasubjoined": "\u0FAB",
+ "/tibt:dzha": "\u0F5C",
+ "/tibt:dzhasubjoined": "\u0FAC",
+ "/tibt:eevowelsign": "\u0F7B",
+ "/tibt:eight": "\u0F28",
+ "/tibt:evowelsign": "\u0F7A",
+ "/tibt:five": "\u0F25",
+ "/tibt:four": "\u0F24",
+ "/tibt:ga": "\u0F42",
+ "/tibt:gasubjoined": "\u0F92",
+ "/tibt:gha": "\u0F43",
+ "/tibt:ghasubjoined": "\u0F93",
+ "/tibt:grucanrgyingssign": "\u0F8A",
+ "/tibt:grumedrgyingssign": "\u0F8B",
+ "/tibt:gtertshegmark": "\u0F14",
+ "/tibt:gteryigmgotruncatedamark": "\u0F01",
+ "/tibt:gteryigmgoumgtertshegmamark": "\u0F03",
+ "/tibt:gteryigmgoumrnambcadmamark": "\u0F02",
+ "/tibt:gugrtagsgyasmark": "\u0F3B",
+ "/tibt:gugrtagsgyonmark": "\u0F3A",
+ "/tibt:ha": "\u0F67",
+ "/tibt:halantamark": "\u0F84",
+ "/tibt:halfeight": "\u0F31",
+ "/tibt:halffive": "\u0F2E",
+ "/tibt:halffour": "\u0F2D",
+ "/tibt:halfnine": "\u0F32",
+ "/tibt:halfone": "\u0F2A",
+ "/tibt:halfseven": "\u0F30",
+ "/tibt:halfsix": "\u0F2F",
+ "/tibt:halfthree": "\u0F2C",
+ "/tibt:halftwo": "\u0F2B",
+ "/tibt:halfzero": "\u0F33",
+ "/tibt:hasubjoined": "\u0FB7",
+ "/tibt:heavybeatcantillationsign": "\u0FC0",
+ "/tibt:iivowelsign": "\u0F73",
+ "/tibt:intersyllabictshegmark": "\u0F0B",
+ "/tibt:invertedmchucansign": "\u0F8C",
+ "/tibt:invertedmchucansubjoinedsign": "\u0F8F",
+ "/tibt:ivowelsign": "\u0F72",
+ "/tibt:ja": "\u0F47",
+ "/tibt:jasubjoined": "\u0F97",
+ "/tibt:ka": "\u0F40",
+ "/tibt:kasubjoined": "\u0F90",
+ "/tibt:kha": "\u0F41",
+ "/tibt:khasubjoined": "\u0F91",
+ "/tibt:kka": "\u0F6B",
+ "/tibt:kssa": "\u0F69",
+ "/tibt:kssasubjoined": "\u0FB9",
+ "/tibt:kurukha": "\u0FBE",
+ "/tibt:kurukhabzhimigcan": "\u0FBF",
+ "/tibt:la": "\u0F63",
+ "/tibt:lasubjoined": "\u0FB3",
+ "/tibt:lcetsacansign": "\u0F88",
+ "/tibt:lcetsacansubjoinedsign": "\u0F8D",
+ "/tibt:lcirtagssign": "\u0F86",
+ "/tibt:leadingmchanrtagsmark": "\u0FD9",
+ "/tibt:lhagrtagslogotypesign": "\u0F16",
+ "/tibt:lightbeatcantillationsign": "\u0FC1",
+ "/tibt:llvocalicvowelsign": "\u0F79",
+ "/tibt:lvocalicvowelsign": "\u0F78",
+ "/tibt:ma": "\u0F58",
+ "/tibt:martshessign": "\u0F3F",
+ "/tibt:masubjoined": "\u0FA8",
+ "/tibt:mchucansign": "\u0F89",
+ "/tibt:mchucansubjoinedsign": "\u0F8E",
+ "/tibt:mnyamyiggimgorgyanmark": "\u0FD1",
+ "/tibt:na": "\u0F53",
+ "/tibt:nasubjoined": "\u0FA3",
+ "/tibt:nga": "\u0F44",
+ "/tibt:ngasbzungnyizlamark": "\u0F35",
+ "/tibt:ngasbzungsgorrtagsmark": "\u0F37",
+ "/tibt:ngasubjoined": "\u0F94",
+ "/tibt:nine": "\u0F29",
+ "/tibt:nna": "\u0F4E",
+ "/tibt:nnasubjoined": "\u0F9E",
+ "/tibt:norbubzhikhyilsymbol": "\u0FCC",
+ "/tibt:norbugsumkhyilsymbol": "\u0FCB",
+ "/tibt:norbunyiskhyilsymbol": "\u0FCA",
+ "/tibt:norbusymbol": "\u0FC9",
+ "/tibt:nya": "\u0F49",
+ "/tibt:nyasubjoined": "\u0F99",
+ "/tibt:nyisshadmark": "\u0F0E",
+ "/tibt:nyistshegmark": "\u0FD2",
+ "/tibt:nyistshegshadmark": "\u0F10",
+ "/tibt:nyizlanaadasign": "\u0F82",
+ "/tibt:omsyllable": "\u0F00",
+ "/tibt:one": "\u0F21",
+ "/tibt:oovowelsign": "\u0F7D",
+ "/tibt:ovowelsign": "\u0F7C",
+ "/tibt:pa": "\u0F54",
+ "/tibt:padmagdansymbol": "\u0FC6",
+ "/tibt:palutamark": "\u0F85",
+ "/tibt:pasubjoined": "\u0FA4",
+ "/tibt:pha": "\u0F55",
+ "/tibt:phasubjoined": "\u0FA5",
+ "/tibt:phurpasymbol": "\u0FC8",
+ "/tibt:ra": "\u0F62",
+ "/tibt:rafixed": "\u0F6A",
+ "/tibt:rasubjoined": "\u0FB2",
+ "/tibt:rasubjoinedfixed": "\u0FBC",
+ "/tibt:rdeldkargcigsign": "\u0F1A",
+ "/tibt:rdeldkargnyissign": "\u0F1B",
+ "/tibt:rdeldkargsumsign": "\u0F1C",
+ "/tibt:rdeldkarrdelnagsign": "\u0F1F",
+ "/tibt:rdelnaggcigsign": "\u0F1D",
+ "/tibt:rdelnaggnyissign": "\u0F1E",
+ "/tibt:rdelnaggsumsign": "\u0FCF",
+ "/tibt:rdelnagrdeldkarsign": "\u0FCE",
+ "/tibt:rdorjergyagramsymbol": "\u0FC7",
+ "/tibt:rdorjesymbol": "\u0FC5",
+ "/tibt:reversediivowelsign": "\u0F81",
+ "/tibt:reversedivowelsign": "\u0F80",
+ "/tibt:rgyagramshadmark": "\u0F12",
+ "/tibt:rinchenspungsshadmark": "\u0F11",
+ "/tibt:rjessungarosign": "\u0F7E",
+ "/tibt:rnambcadsign": "\u0F7F",
+ "/tibt:rra": "\u0F6C",
+ "/tibt:rrvocalicvowelsign": "\u0F77",
+ "/tibt:rvocalicvowelsign": "\u0F76",
+ "/tibt:sa": "\u0F66",
+ "/tibt:sasubjoined": "\u0FB6",
+ "/tibt:sbrulshadmark": "\u0F08",
+ "/tibt:sbubchalcantillationsign": "\u0FC3",
+ "/tibt:seven": "\u0F27",
+ "/tibt:sha": "\u0F64",
+ "/tibt:shadmark": "\u0F0D",
+ "/tibt:shasubjoined": "\u0FB4",
+ "/tibt:six": "\u0F26",
+ "/tibt:snaldansign": "\u0F83",
+ "/tibt:ssa": "\u0F65",
+ "/tibt:ssasubjoined": "\u0FB5",
+ "/tibt:subjoinedAA": "\u0FB0",
+ "/tibt:svastileft": "\u0FD6",
+ "/tibt:svastileftdot": "\u0FD8",
+ "/tibt:svastiright": "\u0FD5",
+ "/tibt:svastirightdot": "\u0FD7",
+ "/tibt:ta": "\u0F4F",
+ "/tibt:tasubjoined": "\u0F9F",
+ "/tibt:tha": "\u0F50",
+ "/tibt:thasubjoined": "\u0FA0",
+ "/tibt:three": "\u0F23",
+ "/tibt:trailingmchanrtagsmark": "\u0FDA",
+ "/tibt:tsa": "\u0F59",
+ "/tibt:tsaphrumark": "\u0F39",
+ "/tibt:tsasubjoined": "\u0FA9",
+ "/tibt:tsha": "\u0F5A",
+ "/tibt:tshasubjoined": "\u0FAA",
+ "/tibt:tshegshadmark": "\u0F0F",
+ "/tibt:tta": "\u0F4A",
+ "/tibt:ttasubjoined": "\u0F9A",
+ "/tibt:ttha": "\u0F4B",
+ "/tibt:tthasubjoined": "\u0F9B",
+ "/tibt:two": "\u0F22",
+ "/tibt:uuvowelsign": "\u0F75",
+ "/tibt:uvowelsign": "\u0F74",
+ "/tibt:wa": "\u0F5D",
+ "/tibt:wasubjoined": "\u0FAD",
+ "/tibt:wasubjoinedfixed": "\u0FBA",
+ "/tibt:ya": "\u0F61",
+ "/tibt:yangrtagssign": "\u0F87",
+ "/tibt:yartshessign": "\u0F3E",
+ "/tibt:yasubjoined": "\u0FB1",
+ "/tibt:yasubjoinedfixed": "\u0FBB",
+ "/tibt:yigmgomdunmainitialmark": "\u0F04",
+ "/tibt:yigmgosgabmaclosingmark": "\u0F05",
+ "/tibt:yigmgotshegshadmamark": "\u0F07",
+ "/tibt:za": "\u0F5F",
+ "/tibt:zasubjoined": "\u0FAF",
+ "/tibt:zero": "\u0F20",
+ "/tibt:zha": "\u0F5E",
+ "/tibt:zhasubjoined": "\u0FAE",
+ "/ticirclekatakana": "\u32E0",
+ "/tickconvavediamondleftwhite": "\u27E2",
+ "/tickconvavediamondrightwhite": "\u27E3",
+ "/ticket": "\u1F3AB",
+ "/tickleftwhitesquare": "\u27E4",
+ "/tickrightwhitesquare": "\u27E5",
+ "/tifcha:hb": "\u0596",
+ "/tiger": "\u1F405",
+ "/tigerFace": "\u1F42F",
+ "/tihiragana": "\u3061",
+ "/tikatakana": "\u30C1",
+ "/tikatakanahalfwidth": "\uFF81",
+ "/tikeutacirclekorean": "\u3270",
+ "/tikeutaparenkorean": "\u3210",
+ "/tikeutcirclekorean": "\u3262",
+ "/tikeutkorean": "\u3137",
+ "/tikeutparenkorean": "\u3202",
+ "/tilde": "\u02DC",
+ "/tildebelowcmb": "\u0330",
+ "/tildecmb": "\u0303",
+ "/tildecomb": "\u0303",
+ "/tildediaeresisfunc": "\u2368",
+ "/tildedotaccent": "\u2E1E",
+ "/tildedotbelow": "\u2E1F",
+ "/tildedoublecmb": "\u0360",
+ "/tildeequalsreversed": "\u22CD",
+ "/tildelowmod": "\u02F7",
+ "/tildeoperator": "\u223C",
+ "/tildeoverlaycmb": "\u0334",
+ "/tildereversed": "\u223D",
+ "/tildering": "\u2E1B",
+ "/tildetpl": "\u224B",
+ "/tildeverticalcmb": "\u033E",
+ "/timerclock": "\u23F2",
+ "/timescircle": "\u2297",
+ "/tinsular": "\uA787",
+ "/tipehahebrew": "\u0596",
+ "/tipehalefthebrew": "\u0596",
+ "/tippigurmukhi": "\u0A70",
+ "/tiredFace": "\u1F62B",
+ "/tironiansignet": "\u204A",
+ "/tirtatumetespada": "\uA9DE",
+ "/titlocmbcyr": "\u0483",
+ "/titlocyrilliccmb": "\u0483",
+ "/tiwnarmenian": "\u057F",
+ "/tjekomicyr": "\u050F",
+ "/tlinebelow": "\u1E6F",
+ "/tmonospace": "\uFF54",
+ "/toarmenian": "\u0569",
+ "/tocirclekatakana": "\u32E3",
+ "/tocornerarrowNW": "\u21F1",
+ "/tocornerarrowSE": "\u21F2",
+ "/tohiragana": "\u3068",
+ "/toilet": "\u1F6BD",
+ "/tokatakana": "\u30C8",
+ "/tokatakanahalfwidth": "\uFF84",
+ "/tokyoTower": "\u1F5FC",
+ "/tolongvowel": "\uA9B5",
+ "/tomato": "\u1F345",
+ "/tonebarextrahighmod": "\u02E5",
+ "/tonebarextralowmod": "\u02E9",
+ "/tonebarhighmod": "\u02E6",
+ "/tonebarlowmod": "\u02E8",
+ "/tonebarmidmod": "\u02E7",
+ "/tonefive": "\u01BD",
+ "/tonehighbeginmod": "\u02F9",
+ "/tonehighendmod": "\u02FA",
+ "/tonelowbeginmod": "\u02FB",
+ "/tonelowendmod": "\u02FC",
+ "/tonesix": "\u0185",
+ "/tonetwo": "\u01A8",
+ "/tongue": "\u1F445",
+ "/tonos": "\u0384",
+ "/tonsquare": "\u3327",
+ "/topHat": "\u1F3A9",
+ "/topUpwardsArrowAbove": "\u1F51D",
+ "/topatakthai": "\u0E0F",
+ "/tortoiseshellbracketleft": "\u3014",
+ "/tortoiseshellbracketleftsmall": "\uFE5D",
+ "/tortoiseshellbracketleftvertical": "\uFE39",
+ "/tortoiseshellbracketright": "\u3015",
+ "/tortoiseshellbracketrightsmall": "\uFE5E",
+ "/tortoiseshellbracketrightvertical": "\uFE3A",
+ "/totalrunout": "\u2330",
+ "/totaothai": "\u0E15",
+ "/tpalatalhook": "\u01AB",
+ "/tparen": "\u24AF",
+ "/tparenthesized": "\u24AF",
+ "/trackball": "\u1F5B2",
+ "/tractor": "\u1F69C",
+ "/trademark": "\u2122",
+ "/trademarksans": "\uF8EA",
+ "/trademarkserif": "\uF6DB",
+ "/train": "\u1F686",
+ "/tram": "\u1F68A",
+ "/tramCar": "\u1F68B",
+ "/trapeziumwhite": "\u23E2",
+ "/tresillo": "\uA72B",
+ "/tretroflex": "\u0288",
+ "/tretroflexhook": "\u0288",
+ "/triagdn": "\u25BC",
+ "/triaglf": "\u25C4",
+ "/triagrt": "\u25BA",
+ "/triagup": "\u25B2",
+ "/triangleWithRoundedCorners": "\u1F6C6",
+ "/triangledotupwhite": "\u25EC",
+ "/triangledownblack": "\u25BC",
+ "/triangledownsmallblack": "\u25BE",
+ "/triangledownsmallwhite": "\u25BF",
+ "/triangledownwhite": "\u25BD",
+ "/trianglehalfupleftblack": "\u25ED",
+ "/trianglehalfuprightblack": "\u25EE",
+ "/triangleleftblack": "\u25C0",
+ "/triangleleftsmallblack": "\u25C2",
+ "/triangleleftsmallwhite": "\u25C3",
+ "/triangleleftwhite": "\u25C1",
+ "/triangleright": "\u22BF",
+ "/trianglerightblack": "\u25B6",
+ "/trianglerightsmallblack": "\u25B8",
+ "/trianglerightsmallwhite": "\u25B9",
+ "/trianglerightwhite": "\u25B7",
+ "/triangleupblack": "\u25B2",
+ "/triangleupsmallblack": "\u25B4",
+ "/triangleupsmallwhite": "\u25B5",
+ "/triangleupwhite": "\u25B3",
+ "/triangularFlagOnPost": "\u1F6A9",
+ "/triangularRuler": "\u1F4D0",
+ "/triangularbullet": "\u2023",
+ "/tricolon": "\u205D",
+ "/tricontainingtriwhiteanglesmall": "\u27C1",
+ "/tridentEmblem": "\u1F531",
+ "/trigramearth": "\u2637",
+ "/trigramfire": "\u2632",
+ "/trigramheaven": "\u2630",
+ "/trigramlake": "\u2631",
+ "/trigrammountain": "\u2636",
+ "/trigramthunder": "\u2633",
+ "/trigramwater": "\u2635",
+ "/trigramwind": "\u2634",
+ "/triplearrowleft": "\u21DA",
+ "/triplearrowright": "\u21DB",
+ "/tripledot": "\u061E",
+ "/trisememetrical": "\u23D7",
+ "/trns:baby": "\u1F6BC",
+ "/trolleybus": "\u1F68E",
+ "/trophy": "\u1F3C6",
+ "/tropicalDrink": "\u1F379",
+ "/tropicalFish": "\u1F420",
+ "/truckblack": "\u26DF",
+ "/true": "\u22A8",
+ "/trumpet": "\u1F3BA",
+ "/ts": "\u02A6",
+ "/tsadi": "\u05E6",
+ "/tsadi:hb": "\u05E6",
+ "/tsadidagesh": "\uFB46",
+ "/tsadidageshhebrew": "\uFB46",
+ "/tsadihebrew": "\u05E6",
+ "/tsadiwithdagesh:hb": "\uFB46",
+ "/tsecyr": "\u0446",
+ "/tsecyrillic": "\u0446",
+ "/tsere": "\u05B5",
+ "/tsere12": "\u05B5",
+ "/tsere1e": "\u05B5",
+ "/tsere2b": "\u05B5",
+ "/tsere:hb": "\u05B5",
+ "/tserehebrew": "\u05B5",
+ "/tserenarrowhebrew": "\u05B5",
+ "/tserequarterhebrew": "\u05B5",
+ "/tserewidehebrew": "\u05B5",
+ "/tshecyr": "\u045B",
+ "/tshecyrillic": "\u045B",
+ "/tsinnorit:hb": "\u05AE",
+ "/tstroke": "\u2C66",
+ "/tsuperior": "\uF6F3",
+ "/ttabengali": "\u099F",
+ "/ttadeva": "\u091F",
+ "/ttagujarati": "\u0A9F",
+ "/ttagurmukhi": "\u0A1F",
+ "/ttamahaprana": "\uA99C",
+ "/tteh": "\u0679",
+ "/tteh.fina": "\uFB67",
+ "/tteh.init": "\uFB68",
+ "/tteh.isol": "\uFB66",
+ "/tteh.medi": "\uFB69",
+ "/tteharabic": "\u0679",
+ "/tteheh": "\u067A",
+ "/tteheh.fina": "\uFB5F",
+ "/tteheh.init": "\uFB60",
+ "/tteheh.isol": "\uFB5E",
+ "/tteheh.medi": "\uFB61",
+ "/ttehfinalarabic": "\uFB67",
+ "/ttehinitialarabic": "\uFB68",
+ "/ttehmedialarabic": "\uFB69",
+ "/tthabengali": "\u09A0",
+ "/tthadeva": "\u0920",
+ "/tthagujarati": "\u0AA0",
+ "/tthagurmukhi": "\u0A20",
+ "/tturned": "\u0287",
+ "/tucirclekatakana": "\u32E1",
+ "/tugrik": "\u20AE",
+ "/tuhiragana": "\u3064",
+ "/tukatakana": "\u30C4",
+ "/tukatakanahalfwidth": "\uFF82",
+ "/tulip": "\u1F337",
+ "/tum": "\uA777",
+ "/turkishlira": "\u20BA",
+ "/turnedOkHandSign": "\u1F58F",
+ "/turnedcomma": "\u2E32",
+ "/turneddagger": "\u2E38",
+ "/turneddigitthree": "\u218B",
+ "/turneddigittwo": "\u218A",
+ "/turnedpiselehpada": "\uA9CD",
+ "/turnedsemicolon": "\u2E35",
+ "/turnedshogipieceblack": "\u26CA",
+ "/turnedshogipiecewhite": "\u26C9",
+ "/turnstiledblverticalbarright": "\u22AB",
+ "/turnstileleftrightdbl": "\u27DA",
+ "/turnstiletplverticalbarright": "\u22AA",
+ "/turtle": "\u1F422",
+ "/tusmallhiragana": "\u3063",
+ "/tusmallkatakana": "\u30C3",
+ "/tusmallkatakanahalfwidth": "\uFF6F",
+ "/twelve.roman": "\u216B",
+ "/twelve.romansmall": "\u217B",
+ "/twelvecircle": "\u246B",
+ "/twelvecircleblack": "\u24EC",
+ "/twelveparen": "\u247F",
+ "/twelveparenthesized": "\u247F",
+ "/twelveperiod": "\u2493",
+ "/twelveroman": "\u217B",
+ "/twenty-twopointtwosquare": "\u1F1A2",
+ "/twentycircle": "\u2473",
+ "/twentycircleblack": "\u24F4",
+ "/twentycirclesquare": "\u3249",
+ "/twentyeightcircle": "\u3258",
+ "/twentyfivecircle": "\u3255",
+ "/twentyfourcircle": "\u3254",
+ "/twentyhangzhou": "\u5344",
+ "/twentyninecircle": "\u3259",
+ "/twentyonecircle": "\u3251",
+ "/twentyparen": "\u2487",
+ "/twentyparenthesized": "\u2487",
+ "/twentyperiod": "\u249B",
+ "/twentysevencircle": "\u3257",
+ "/twentysixcircle": "\u3256",
+ "/twentythreecircle": "\u3253",
+ "/twentytwocircle": "\u3252",
+ "/twistedRightwardsArrows": "\u1F500",
+ "/two": "\u0032",
+ "/two.inferior": "\u2082",
+ "/two.roman": "\u2161",
+ "/two.romansmall": "\u2171",
+ "/twoButtonMouse": "\u1F5B0",
+ "/twoHearts": "\u1F495",
+ "/twoMenHoldingHands": "\u1F46C",
+ "/twoSpeechBubbles": "\u1F5EA",
+ "/twoWomenHoldingHands": "\u1F46D",
+ "/twoarabic": "\u0662",
+ "/twoasterisksalignedvertically": "\u2051",
+ "/twobengali": "\u09E8",
+ "/twocircle": "\u2461",
+ "/twocircledbl": "\u24F6",
+ "/twocircleinversesansserif": "\u278B",
+ "/twocomma": "\u1F103",
+ "/twodeva": "\u0968",
+ "/twodotenleader": "\u2025",
+ "/twodotleader": "\u2025",
+ "/twodotleadervertical": "\uFE30",
+ "/twodotpunctuation": "\u205A",
+ "/twodotsoveronedot": "\u2E2A",
+ "/twofar": "\u06F2",
+ "/twofifths": "\u2156",
+ "/twogujarati": "\u0AE8",
+ "/twogurmukhi": "\u0A68",
+ "/twohackarabic": "\u0662",
+ "/twohangzhou": "\u3022",
+ "/twoideographiccircled": "\u3281",
+ "/twoideographicparen": "\u3221",
+ "/twoinferior": "\u2082",
+ "/twoksquare": "\u1F19D",
+ "/twomonospace": "\uFF12",
+ "/twonumeratorbengali": "\u09F5",
+ "/twooldstyle": "\uF732",
+ "/twoparen": "\u2475",
+ "/twoparenthesized": "\u2475",
+ "/twoperiod": "\u2489",
+ "/twopersian": "\u06F2",
+ "/tworoman": "\u2171",
+ "/twoshortsjoinedmetrical": "\u23D6",
+ "/twoshortsoverlongmetrical": "\u23D5",
+ "/twostroke": "\u01BB",
+ "/twosuperior": "\u00B2",
+ "/twothai": "\u0E52",
+ "/twothirds": "\u2154",
+ "/twowayleftwaytrafficblack": "\u26D6",
+ "/twowayleftwaytrafficwhite": "\u26D7",
+ "/tz": "\uA729",
+ "/u": "\u0075",
+ "/u.fina": "\uFBD8",
+ "/u.isol": "\uFBD7",
+ "/uacute": "\u00FA",
+ "/uacutedblcyr": "\u04F3",
+ "/ubar": "\u0289",
+ "/ubengali": "\u0989",
+ "/ubopomofo": "\u3128",
+ "/ubracketleft": "\u2E26",
+ "/ubracketright": "\u2E27",
+ "/ubreve": "\u016D",
+ "/ucaron": "\u01D4",
+ "/ucircle": "\u24E4",
+ "/ucirclekatakana": "\u32D2",
+ "/ucircumflex": "\u00FB",
+ "/ucircumflexbelow": "\u1E77",
+ "/ucyr": "\u0443",
+ "/ucyrillic": "\u0443",
+ "/udattadeva": "\u0951",
+ "/udblacute": "\u0171",
+ "/udblgrave": "\u0215",
+ "/udeva": "\u0909",
+ "/udieresis": "\u00FC",
+ "/udieresisacute": "\u01D8",
+ "/udieresisbelow": "\u1E73",
+ "/udieresiscaron": "\u01DA",
+ "/udieresiscyr": "\u04F1",
+ "/udieresiscyrillic": "\u04F1",
+ "/udieresisgrave": "\u01DC",
+ "/udieresismacron": "\u01D6",
+ "/udotbelow": "\u1EE5",
+ "/ugrave": "\u00F9",
+ "/ugravedbl": "\u0215",
+ "/ugujarati": "\u0A89",
+ "/ugurmukhi": "\u0A09",
+ "/uhamza": "\u0677",
+ "/uhamza.isol": "\uFBDD",
+ "/uhdsquare": "\u1F1AB",
+ "/uhiragana": "\u3046",
+ "/uhoi": "\u1EE7",
+ "/uhookabove": "\u1EE7",
+ "/uhorn": "\u01B0",
+ "/uhornacute": "\u1EE9",
+ "/uhorndotbelow": "\u1EF1",
+ "/uhorngrave": "\u1EEB",
+ "/uhornhoi": "\u1EED",
+ "/uhornhookabove": "\u1EED",
+ "/uhorntilde": "\u1EEF",
+ "/uhungarumlaut": "\u0171",
+ "/uhungarumlautcyrillic": "\u04F3",
+ "/uighurkazakhkirghizalefmaksura.init": "\uFBE8",
+ "/uighurkazakhkirghizalefmaksura.medi": "\uFBE9",
+ "/uighurkirghizyeh.init_hamzaabove.medi_alefmaksura.fina": "\uFBF9",
+ "/uighurkirghizyeh.init_hamzaabove.medi_alefmaksura.medi": "\uFBFB",
+ "/uighurkirghizyeh.medi_hamzaabove.medi_alefmaksura.fina": "\uFBFA",
+ "/uinvertedbreve": "\u0217",
+ "/ukatakana": "\u30A6",
+ "/ukatakanahalfwidth": "\uFF73",
+ "/ukcyr": "\u0479",
+ "/ukcyrillic": "\u0479",
+ "/ukorean": "\u315C",
+ "/um": "\uA778",
+ "/umacron": "\u016B",
+ "/umacroncyr": "\u04EF",
+ "/umacroncyrillic": "\u04EF",
+ "/umacrondieresis": "\u1E7B",
+ "/umatragurmukhi": "\u0A41",
+ "/umbrella": "\u2602",
+ "/umbrellaonground": "\u26F1",
+ "/umbrellaraindrops": "\u2614",
+ "/umonospace": "\uFF55",
+ "/unamusedFace": "\u1F612",
+ "/unaspiratedmod": "\u02ED",
+ "/underscore": "\u005F",
+ "/underscorecenterline": "\uFE4E",
+ "/underscoredashed": "\uFE4D",
+ "/underscoredbl": "\u2017",
+ "/underscoremonospace": "\uFF3F",
+ "/underscorevertical": "\uFE33",
+ "/underscorewavy": "\uFE4F",
+ "/underscorewavyvertical": "\uFE34",
+ "/undertie": "\u203F",
+ "/undo": "\u238C",
+ "/union": "\u222A",
+ "/unionarray": "\u22C3",
+ "/uniondbl": "\u22D3",
+ "/universal": "\u2200",
+ "/unmarriedpartnership": "\u26AF",
+ "/uogonek": "\u0173",
+ "/uonsquare": "\u3306",
+ "/upPointingAirplane": "\u1F6E7",
+ "/upPointingMilitaryAirplane": "\u1F6E6",
+ "/upPointingSmallAirplane": "\u1F6E8",
+ "/uparen": "\u24B0",
+ "/uparenthesized": "\u24B0",
+ "/uparrowleftofdownarrow": "\u21C5",
+ "/upblock": "\u2580",
+ "/updblhorzsng": "\u2568",
+ "/updblleftsng": "\u255C",
+ "/updblrightsng": "\u2559",
+ "/upheavydnhorzlight": "\u2540",
+ "/upheavyhorzlight": "\u2538",
+ "/upheavyleftdnlight": "\u2526",
+ "/upheavyleftlight": "\u251A",
+ "/upheavyrightdnlight": "\u251E",
+ "/upheavyrightlight": "\u2516",
+ "/uplightdnhorzheavy": "\u2548",
+ "/uplighthorzheavy": "\u2537",
+ "/uplightleftdnheavy": "\u252A",
+ "/uplightleftheavy": "\u2519",
+ "/uplightrightdnheavy": "\u2522",
+ "/uplightrightheavy": "\u2515",
+ "/upperHalfBlock": "\u2580",
+ "/upperOneEighthBlock": "\u2594",
+ "/upperRightShadowedWhiteCircle": "\u1F53F",
+ "/upperdothebrew": "\u05C4",
+ "/upperhalfcircle": "\u25E0",
+ "/upperhalfcircleinversewhite": "\u25DA",
+ "/upperquadrantcirculararcleft": "\u25DC",
+ "/upperquadrantcirculararcright": "\u25DD",
+ "/uppertriangleleft": "\u25F8",
+ "/uppertriangleleftblack": "\u25E4",
+ "/uppertriangleright": "\u25F9",
+ "/uppertrianglerightblack": "\u25E5",
+ "/upsideDownFace": "\u1F643",
+ "/upsilon": "\u03C5",
+ "/upsilonacute": "\u1F7B",
+ "/upsilonasper": "\u1F51",
+ "/upsilonasperacute": "\u1F55",
+ "/upsilonaspergrave": "\u1F53",
+ "/upsilonaspertilde": "\u1F57",
+ "/upsilonbreve": "\u1FE0",
+ "/upsilondieresis": "\u03CB",
+ "/upsilondieresisacute": "\u1FE3",
+ "/upsilondieresisgrave": "\u1FE2",
+ "/upsilondieresistilde": "\u1FE7",
+ "/upsilondieresistonos": "\u03B0",
+ "/upsilongrave": "\u1F7A",
+ "/upsilonlatin": "\u028A",
+ "/upsilonlenis": "\u1F50",
+ "/upsilonlenisacute": "\u1F54",
+ "/upsilonlenisgrave": "\u1F52",
+ "/upsilonlenistilde": "\u1F56",
+ "/upsilontilde": "\u1FE6",
+ "/upsilontonos": "\u03CD",
+ "/upsilonwithmacron": "\u1FE1",
+ "/upsnghorzdbl": "\u2567",
+ "/upsngleftdbl": "\u255B",
+ "/upsngrightdbl": "\u2558",
+ "/uptackbelowcmb": "\u031D",
+ "/uptackmod": "\u02D4",
+ "/upwithexclamationmarksquare": "\u1F199",
+ "/uragurmukhi": "\u0A73",
+ "/uranus": "\u2645",
+ "/uring": "\u016F",
+ "/ushortcyr": "\u045E",
+ "/ushortcyrillic": "\u045E",
+ "/usmallhiragana": "\u3045",
+ "/usmallkatakana": "\u30A5",
+ "/usmallkatakanahalfwidth": "\uFF69",
+ "/usmod": "\uA770",
+ "/ustraightcyr": "\u04AF",
+ "/ustraightcyrillic": "\u04AF",
+ "/ustraightstrokecyr": "\u04B1",
+ "/ustraightstrokecyrillic": "\u04B1",
+ "/utilde": "\u0169",
+ "/utildeacute": "\u1E79",
+ "/utildebelow": "\u1E75",
+ "/uubengali": "\u098A",
+ "/uudeva": "\u090A",
+ "/uugujarati": "\u0A8A",
+ "/uugurmukhi": "\u0A0A",
+ "/uumatragurmukhi": "\u0A42",
+ "/uuvowelsignbengali": "\u09C2",
+ "/uuvowelsigndeva": "\u0942",
+ "/uuvowelsigngujarati": "\u0AC2",
+ "/uvowelsignbengali": "\u09C1",
+ "/uvowelsigndeva": "\u0941",
+ "/uvowelsigngujarati": "\u0AC1",
+ "/v": "\u0076",
+ "/vadeva": "\u0935",
+ "/vagujarati": "\u0AB5",
+ "/vagurmukhi": "\u0A35",
+ "/vakatakana": "\u30F7",
+ "/vanedownfunc": "\u2356",
+ "/vaneleftfunc": "\u2345",
+ "/vanerightfunc": "\u2346",
+ "/vaneupfunc": "\u234F",
+ "/varikajudeospanish:hb": "\uFB1E",
+ "/vav": "\u05D5",
+ "/vav:hb": "\u05D5",
+ "/vav_vav:hb": "\u05F0",
+ "/vav_yod:hb": "\u05F1",
+ "/vavdagesh": "\uFB35",
+ "/vavdagesh65": "\uFB35",
+ "/vavdageshhebrew": "\uFB35",
+ "/vavhebrew": "\u05D5",
+ "/vavholam": "\uFB4B",
+ "/vavholamhebrew": "\uFB4B",
+ "/vavvavhebrew": "\u05F0",
+ "/vavwithdagesh:hb": "\uFB35",
+ "/vavwithholam:hb": "\uFB4B",
+ "/vavyodhebrew": "\u05F1",
+ "/vcircle": "\u24E5",
+ "/vcurl": "\u2C74",
+ "/vdiagonalstroke": "\uA75F",
+ "/vdotbelow": "\u1E7F",
+ "/ve.fina": "\uFBDF",
+ "/ve.isol": "\uFBDE",
+ "/ve:abovetonecandra": "\u1CF4",
+ "/ve:anusvaraantargomukhasign": "\u1CE9",
+ "/ve:anusvarabahirgomukhasign": "\u1CEA",
+ "/ve:anusvarasignlong": "\u1CEF",
+ "/ve:anusvaraubhayatomukhasign": "\u1CF1",
+ "/ve:anusvaravamagomukhasign": "\u1CEB",
+ "/ve:anusvaravamagomukhawithtailsign": "\u1CEC",
+ "/ve:ardhavisargasign": "\u1CF2",
+ "/ve:atharvaindependentsvaritatone": "\u1CE1",
+ "/ve:atikramasign": "\u1CF7",
+ "/ve:belowtonecandra": "\u1CD8",
+ "/ve:dotbelowtone": "\u1CDD",
+ "/ve:hexiformanusvarasignlong": "\u1CEE",
+ "/ve:jihvamuliyasign": "\u1CF5",
+ "/ve:karshanatone": "\u1CD0",
+ "/ve:kathakaanudattatone": "\u1CDC",
+ "/ve:nihshvasasign": "\u1CD3",
+ "/ve:prenkhatone": "\u1CD2",
+ "/ve:rigkashmiriindependentsvaritatone": "\u1CE0",
+ "/ve:ringabovetone": "\u1CF8",
+ "/ve:ringabovetonedbl": "\u1CF9",
+ "/ve:rotatedardhavisargasign": "\u1CF3",
+ "/ve:rthanganusvarasignlong": "\u1CF0",
+ "/ve:sharatone": "\u1CD1",
+ "/ve:svaritatonedbl": "\u1CDA",
+ "/ve:svaritatonetpl": "\u1CDB",
+ "/ve:threedotsbelowtone": "\u1CDF",
+ "/ve:tiryaksign": "\u1CED",
+ "/ve:twodotsbelowtone": "\u1CDE",
+ "/ve:upadhmaniyasign": "\u1CF6",
+ "/ve:visargaanudattasign": "\u1CE5",
+ "/ve:visargaanudattasignreversed": "\u1CE6",
+ "/ve:visargaanudattawithtailsign": "\u1CE8",
+ "/ve:visargasvaritasign": "\u1CE2",
+ "/ve:visargaudattasign": "\u1CE3",
+ "/ve:visargaudattasignreversed": "\u1CE4",
+ "/ve:visargaudattawithtailsign": "\u1CE7",
+ "/ve:yajuraggravatedindependentsvaritatone": "\u1CD5",
+ "/ve:yajurindependentsvaritatone": "\u1CD6",
+ "/ve:yajurkathakaindependentsvaritaschroedertone": "\u1CD9",
+ "/ve:yajurkathakaindependentsvaritatone": "\u1CD7",
+ "/ve:yajurmidlinesvaritasign": "\u1CD4",
+ "/vecyr": "\u0432",
+ "/vecyrillic": "\u0432",
+ "/veh": "\u06A4",
+ "/veh.fina": "\uFB6B",
+ "/veh.init": "\uFB6C",
+ "/veh.isol": "\uFB6A",
+ "/veh.medi": "\uFB6D",
+ "/veharabic": "\u06A4",
+ "/vehfinalarabic": "\uFB6B",
+ "/vehinitialarabic": "\uFB6C",
+ "/vehmedialarabic": "\uFB6D",
+ "/vekatakana": "\u30F9",
+ "/vend": "\uA769",
+ "/venus": "\u2640",
+ "/versicle": "\u2123",
+ "/vert:bracketwhiteleft": "\uFE17",
+ "/vert:brakcetwhiteright": "\uFE18",
+ "/vert:colon": "\uFE13",
+ "/vert:comma": "\uFE10",
+ "/vert:ellipsishor": "\uFE19",
+ "/vert:exclam": "\uFE15",
+ "/vert:ideographiccomma": "\uFE11",
+ "/vert:ideographicfullstop": "\uFE12",
+ "/vert:question": "\uFE16",
+ "/vert:semicolon": "\uFE14",
+ "/vertdblhorzsng": "\u256B",
+ "/vertdblleftsng": "\u2562",
+ "/vertdblrightsng": "\u255F",
+ "/vertheavyhorzlight": "\u2542",
+ "/vertheavyleftlight": "\u2528",
+ "/vertheavyrightlight": "\u2520",
+ "/verticalTrafficLight": "\u1F6A6",
+ "/verticalbar": "\u007C",
+ "/verticalbardbl": "\u2016",
+ "/verticalbarhorizontalstroke": "\u27CA",
+ "/verticalbarwhitearrowonpedestalup": "\u21ED",
+ "/verticalfourdots": "\u205E",
+ "/verticalideographiciterationmark": "\u303B",
+ "/verticalkanarepeatmark": "\u3031",
+ "/verticalkanarepeatmarklowerhalf": "\u3035",
+ "/verticalkanarepeatmarkupperhalf": "\u3033",
+ "/verticalkanarepeatwithvoicedsoundmark": "\u3032",
+ "/verticalkanarepeatwithvoicedsoundmarkupperhalf": "\u3034",
+ "/verticallineabovecmb": "\u030D",
+ "/verticallinebelowcmb": "\u0329",
+ "/verticallinelowmod": "\u02CC",
+ "/verticallinemod": "\u02C8",
+ "/verticalmalestroke": "\u26A8",
+ "/verticalsdbltrokearrowleft": "\u21FA",
+ "/verticalsdbltrokearrowleftright": "\u21FC",
+ "/verticalsdbltrokearrowright": "\u21FB",
+ "/verticalstrokearrowleft": "\u21F7",
+ "/verticalstrokearrowleftright": "\u21F9",
+ "/verticalstrokearrowright": "\u21F8",
+ "/vertlighthorzheavy": "\u253F",
+ "/vertlightleftheavy": "\u2525",
+ "/vertlightrightheavy": "\u251D",
+ "/vertsnghorzdbl": "\u256A",
+ "/vertsngleftdbl": "\u2561",
+ "/vertsngrightdbl": "\u255E",
+ "/verymuchgreater": "\u22D9",
+ "/verymuchless": "\u22D8",
+ "/vesta": "\u26B6",
+ "/vewarmenian": "\u057E",
+ "/vhook": "\u028B",
+ "/vibrationMode": "\u1F4F3",
+ "/videoCamera": "\u1F4F9",
+ "/videoGame": "\u1F3AE",
+ "/videocassette": "\u1F4FC",
+ "/viewdatasquare": "\u2317",
+ "/vikatakana": "\u30F8",
+ "/violin": "\u1F3BB",
+ "/viramabengali": "\u09CD",
+ "/viramadeva": "\u094D",
+ "/viramagujarati": "\u0ACD",
+ "/virgo": "\u264D",
+ "/visargabengali": "\u0983",
+ "/visargadeva": "\u0903",
+ "/visargagujarati": "\u0A83",
+ "/visigothicz": "\uA763",
+ "/vmonospace": "\uFF56",
+ "/voarmenian": "\u0578",
+ "/vodsquare": "\u1F1AC",
+ "/voicediterationhiragana": "\u309E",
+ "/voicediterationkatakana": "\u30FE",
+ "/voicedmarkkana": "\u309B",
+ "/voicedmarkkanahalfwidth": "\uFF9E",
+ "/voicingmod": "\u02EC",
+ "/vokatakana": "\u30FA",
+ "/volapukae": "\uA79B",
+ "/volapukoe": "\uA79D",
+ "/volapukue": "\uA79F",
+ "/volcano": "\u1F30B",
+ "/volleyball": "\u1F3D0",
+ "/vovermfullwidth": "\u33DE",
+ "/vowelVabove": "\u065A",
+ "/voweldotbelow": "\u065C",
+ "/vowelinvertedVabove": "\u065B",
+ "/vparen": "\u24B1",
+ "/vparenthesized": "\u24B1",
+ "/vrighthook": "\u2C71",
+ "/vssquare": "\u1F19A",
+ "/vtilde": "\u1E7D",
+ "/vturned": "\u028C",
+ "/vuhiragana": "\u3094",
+ "/vukatakana": "\u30F4",
+ "/vwelsh": "\u1EFD",
+ "/vy": "\uA761",
+ "/w": "\u0077",
+ "/wacirclekatakana": "\u32FB",
+ "/wacute": "\u1E83",
+ "/waekorean": "\u3159",
+ "/wahiragana": "\u308F",
+ "/wakatakana": "\u30EF",
+ "/wakatakanahalfwidth": "\uFF9C",
+ "/wakorean": "\u3158",
+ "/waningCrescentMoon": "\u1F318",
+ "/waningGibbousMoon": "\u1F316",
+ "/warning": "\u26A0",
+ "/wasmallhiragana": "\u308E",
+ "/wasmallkatakana": "\u30EE",
+ "/wastebasket": "\u1F5D1",
+ "/watch": "\u231A",
+ "/waterBuffalo": "\u1F403",
+ "/waterCloset": "\u1F6BE",
+ "/waterWave": "\u1F30A",
+ "/waterideographiccircled": "\u328C",
+ "/waterideographicparen": "\u322C",
+ "/watermelon": "\u1F349",
+ "/wattosquare": "\u3357",
+ "/wavedash": "\u301C",
+ "/wavingBlackFlag": "\u1F3F4",
+ "/wavingHandSign": "\u1F44B",
+ "/wavingWhiteFlag": "\u1F3F3",
+ "/wavydash": "\u3030",
+ "/wavyhamzabelow": "\u065F",
+ "/wavyline": "\u2307",
+ "/wavyunderscorevertical": "\uFE34",
+ "/waw": "\u0648",
+ "/waw.fina": "\uFEEE",
+ "/waw.isol": "\uFEED",
+ "/wawDigitThreeAbove": "\u0779",
+ "/wawDigitTwoAbove": "\u0778",
+ "/wawarabic": "\u0648",
+ "/wawdotabove": "\u06CF",
+ "/wawfinalarabic": "\uFEEE",
+ "/wawhamza": "\u0624",
+ "/wawhamza.fina": "\uFE86",
+ "/wawhamza.isol": "\uFE85",
+ "/wawhamzaabovearabic": "\u0624",
+ "/wawhamzaabovefinalarabic": "\uFE86",
+ "/wawhighhamza": "\u0676",
+ "/wawring": "\u06C4",
+ "/wawsmall": "\u06E5",
+ "/wawtwodotsabove": "\u06CA",
+ "/waxingCrescentMoon": "\u1F312",
+ "/waxingGibbousMoon": "\u1F314",
+ "/wbfullwidth": "\u33DD",
+ "/wbsquare": "\u33DD",
+ "/wcircle": "\u24E6",
+ "/wcircumflex": "\u0175",
+ "/wcsquare": "\u1F14F",
+ "/wcsquareblack": "\u1F18F",
+ "/wdieresis": "\u1E85",
+ "/wdot": "\u1E87",
+ "/wdotaccent": "\u1E87",
+ "/wdotbelow": "\u1E89",
+ "/wearyCatFace": "\u1F640",
+ "/wearyFace": "\u1F629",
+ "/wecirclekatakana": "\u32FD",
+ "/wecyr": "\u051D",
+ "/wedding": "\u1F492",
+ "/wehiragana": "\u3091",
+ "/weierstrass": "\u2118",
+ "/weightLifter": "\u1F3CB",
+ "/wekatakana": "\u30F1",
+ "/wekorean": "\u315E",
+ "/weokorean": "\u315D",
+ "/westsyriaccross": "\u2670",
+ "/wgrave": "\u1E81",
+ "/whale": "\u1F40B",
+ "/wheelchair": "\u267F",
+ "/wheelofdharma": "\u2638",
+ "/whiteDownPointingBackhandIndex": "\u1F447",
+ "/whiteDownPointingLeftHandIndex": "\u1F597",
+ "/whiteFlower": "\u1F4AE",
+ "/whiteHardShellFloppyDisk": "\u1F5AB",
+ "/whiteLatinCross": "\u1F546",
+ "/whiteLeftPointingBackhandIndex": "\u1F448",
+ "/whitePennant": "\u1F3F1",
+ "/whiteRightPointingBackhandIndex": "\u1F449",
+ "/whiteSquareButton": "\u1F533",
+ "/whiteSun": "\u1F323",
+ "/whiteSunBehindCloud": "\u1F325",
+ "/whiteSunBehindCloudRain": "\u1F326",
+ "/whiteSunSmallCloud": "\u1F324",
+ "/whiteTouchtoneTelephone": "\u1F57E",
+ "/whiteUpPointingBackhandIndex": "\u1F446",
+ "/whitearrowdown": "\u21E9",
+ "/whitearrowfromwallright": "\u21F0",
+ "/whitearrowleft": "\u21E6",
+ "/whitearrowonpedestalup": "\u21EB",
+ "/whitearrowright": "\u21E8",
+ "/whitearrowup": "\u21E7",
+ "/whitearrowupdown": "\u21F3",
+ "/whitearrowupfrombar": "\u21EA",
+ "/whitebullet": "\u25E6",
+ "/whitecircle": "\u25CB",
+ "/whitecircleinverse": "\u25D9",
+ "/whitecornerbracketleft": "\u300E",
+ "/whitecornerbracketleftvertical": "\uFE43",
+ "/whitecornerbracketright": "\u300F",
+ "/whitecornerbracketrightvertical": "\uFE44",
+ "/whitedblarrowonpedestalup": "\u21EF",
+ "/whitedblarrowup": "\u21EE",
+ "/whitediamond": "\u25C7",
+ "/whitediamondcontainingblacksmalldiamond": "\u25C8",
+ "/whitedownpointingsmalltriangle": "\u25BF",
+ "/whitedownpointingtriangle": "\u25BD",
+ "/whiteleftpointingsmalltriangle": "\u25C3",
+ "/whiteleftpointingtriangle": "\u25C1",
+ "/whitelenticularbracketleft": "\u3016",
+ "/whitelenticularbracketright": "\u3017",
+ "/whiterightpointingsmalltriangle": "\u25B9",
+ "/whiterightpointingtriangle": "\u25B7",
+ "/whitesesamedot": "\uFE46",
+ "/whitesmallsquare": "\u25AB",
+ "/whitesmilingface": "\u263A",
+ "/whitesquare": "\u25A1",
+ "/whitesquarebracketleft": "\u301A",
+ "/whitesquarebracketright": "\u301B",
+ "/whitestar": "\u2606",
+ "/whitetelephone": "\u260F",
+ "/whitetortoiseshellbracketleft": "\u3018",
+ "/whitetortoiseshellbracketright": "\u3019",
+ "/whiteuppointingsmalltriangle": "\u25B5",
+ "/whiteuppointingtriangle": "\u25B3",
+ "/whook": "\u2C73",
+ "/wicirclekatakana": "\u32FC",
+ "/wigglylinevertical": "\u2E3E",
+ "/wignyan": "\uA983",
+ "/wihiragana": "\u3090",
+ "/wikatakana": "\u30F0",
+ "/wikorean": "\u315F",
+ "/windBlowingFace": "\u1F32C",
+ "/windChime": "\u1F390",
+ "/windupada": "\uA9C6",
+ "/wineGlass": "\u1F377",
+ "/winkingFace": "\u1F609",
+ "/wiredKeyboard": "\u1F5AE",
+ "/wmonospace": "\uFF57",
+ "/wocirclekatakana": "\u32FE",
+ "/wohiragana": "\u3092",
+ "/wokatakana": "\u30F2",
+ "/wokatakanahalfwidth": "\uFF66",
+ "/wolfFace": "\u1F43A",
+ "/woman": "\u1F469",
+ "/womanBunnyEars": "\u1F46F",
+ "/womansBoots": "\u1F462",
+ "/womansClothes": "\u1F45A",
+ "/womansHat": "\u1F452",
+ "/womansSandal": "\u1F461",
+ "/womens": "\u1F6BA",
+ "/won": "\u20A9",
+ "/wonmonospace": "\uFFE6",
+ "/woodideographiccircled": "\u328D",
+ "/woodideographicparen": "\u322D",
+ "/wordjoiner": "\u2060",
+ "/wordseparatormiddledot": "\u2E31",
+ "/worldMap": "\u1F5FA",
+ "/worriedFace": "\u1F61F",
+ "/wowaenthai": "\u0E27",
+ "/wparen": "\u24B2",
+ "/wparenthesized": "\u24B2",
+ "/wrappedPresent": "\u1F381",
+ "/wreathproduct": "\u2240",
+ "/wrench": "\u1F527",
+ "/wring": "\u1E98",
+ "/wsuperior": "\u02B7",
+ "/wsupmod": "\u02B7",
+ "/wturned": "\u028D",
+ "/wulumelikvowel": "\uA9B7",
+ "/wuluvowel": "\uA9B6",
+ "/wynn": "\u01BF",
+ "/x": "\u0078",
+ "/x.inferior": "\u2093",
+ "/xabovecmb": "\u033D",
+ "/xatailcyr": "\u04B3",
+ "/xbopomofo": "\u3112",
+ "/xcircle": "\u24E7",
+ "/xdieresis": "\u1E8D",
+ "/xdot": "\u1E8B",
+ "/xdotaccent": "\u1E8B",
+ "/xeharmenian": "\u056D",
+ "/xi": "\u03BE",
+ "/xmonospace": "\uFF58",
+ "/xor": "\u22BB",
+ "/xparen": "\u24B3",
+ "/xparenthesized": "\u24B3",
+ "/xsuperior": "\u02E3",
+ "/xsupmod": "\u02E3",
+ "/y": "\u0079",
+ "/yaadosquare": "\u334E",
+ "/yaarusquare": "\u334F",
+ "/yabengali": "\u09AF",
+ "/yacirclekatakana": "\u32F3",
+ "/yacute": "\u00FD",
+ "/yacyr": "\u044F",
+ "/yadeva": "\u092F",
+ "/yaecyr": "\u0519",
+ "/yaekorean": "\u3152",
+ "/yagujarati": "\u0AAF",
+ "/yagurmukhi": "\u0A2F",
+ "/yahiragana": "\u3084",
+ "/yakatakana": "\u30E4",
+ "/yakatakanahalfwidth": "\uFF94",
+ "/yakorean": "\u3151",
+ "/yamakkanthai": "\u0E4E",
+ "/yangtonemod": "\u02EB",
+ "/yasmallhiragana": "\u3083",
+ "/yasmallkatakana": "\u30E3",
+ "/yasmallkatakanahalfwidth": "\uFF6C",
+ "/yatcyr": "\u0463",
+ "/yatcyrillic": "\u0463",
+ "/ycircle": "\u24E8",
+ "/ycircumflex": "\u0177",
+ "/ydieresis": "\u00FF",
+ "/ydot": "\u1E8F",
+ "/ydotaccent": "\u1E8F",
+ "/ydotbelow": "\u1EF5",
+ "/yeh": "\u064A",
+ "/yeh.fina": "\uFEF2",
+ "/yeh.init": "\uFEF3",
+ "/yeh.init_alefmaksura.fina": "\uFC59",
+ "/yeh.init_hah.fina": "\uFC56",
+ "/yeh.init_hah.medi": "\uFCDB",
+ "/yeh.init_hamzaabove.medi_ae.fina": "\uFBEC",
+ "/yeh.init_hamzaabove.medi_alef.fina": "\uFBEA",
+ "/yeh.init_hamzaabove.medi_alefmaksura.fina": "\uFC03",
+ "/yeh.init_hamzaabove.medi_e.fina": "\uFBF6",
+ "/yeh.init_hamzaabove.medi_e.medi": "\uFBF8",
+ "/yeh.init_hamzaabove.medi_hah.fina": "\uFC01",
+ "/yeh.init_hamzaabove.medi_hah.medi": "\uFC98",
+ "/yeh.init_hamzaabove.medi_heh.medi": "\uFC9B",
+ "/yeh.init_hamzaabove.medi_jeem.fina": "\uFC00",
+ "/yeh.init_hamzaabove.medi_jeem.medi": "\uFC97",
+ "/yeh.init_hamzaabove.medi_khah.medi": "\uFC99",
+ "/yeh.init_hamzaabove.medi_meem.fina": "\uFC02",
+ "/yeh.init_hamzaabove.medi_meem.medi": "\uFC9A",
+ "/yeh.init_hamzaabove.medi_oe.fina": "\uFBF2",
+ "/yeh.init_hamzaabove.medi_u.fina": "\uFBF0",
+ "/yeh.init_hamzaabove.medi_waw.fina": "\uFBEE",
+ "/yeh.init_hamzaabove.medi_yeh.fina": "\uFC04",
+ "/yeh.init_hamzaabove.medi_yu.fina": "\uFBF4",
+ "/yeh.init_heh.medi": "\uFCDE",
+ "/yeh.init_jeem.fina": "\uFC55",
+ "/yeh.init_jeem.medi": "\uFCDA",
+ "/yeh.init_khah.fina": "\uFC57",
+ "/yeh.init_khah.medi": "\uFCDC",
+ "/yeh.init_meem.fina": "\uFC58",
+ "/yeh.init_meem.medi": "\uFCDD",
+ "/yeh.init_meem.medi_meem.medi": "\uFD9D",
+ "/yeh.init_yeh.fina": "\uFC5A",
+ "/yeh.isol": "\uFEF1",
+ "/yeh.medi": "\uFEF4",
+ "/yeh.medi_alefmaksura.fina": "\uFC95",
+ "/yeh.medi_hah.medi_yeh.fina": "\uFDAE",
+ "/yeh.medi_hamzaabove.medi_ae.fina": "\uFBED",
+ "/yeh.medi_hamzaabove.medi_alef.fina": "\uFBEB",
+ "/yeh.medi_hamzaabove.medi_alefmaksura.fina": "\uFC68",
+ "/yeh.medi_hamzaabove.medi_e.fina": "\uFBF7",
+ "/yeh.medi_hamzaabove.medi_heh.medi": "\uFCE0",
+ "/yeh.medi_hamzaabove.medi_meem.fina": "\uFC66",
+ "/yeh.medi_hamzaabove.medi_meem.medi": "\uFCDF",
+ "/yeh.medi_hamzaabove.medi_noon.fina": "\uFC67",
+ "/yeh.medi_hamzaabove.medi_oe.fina": "\uFBF3",
+ "/yeh.medi_hamzaabove.medi_reh.fina": "\uFC64",
+ "/yeh.medi_hamzaabove.medi_u.fina": "\uFBF1",
+ "/yeh.medi_hamzaabove.medi_waw.fina": "\uFBEF",
+ "/yeh.medi_hamzaabove.medi_yeh.fina": "\uFC69",
+ "/yeh.medi_hamzaabove.medi_yu.fina": "\uFBF5",
+ "/yeh.medi_hamzaabove.medi_zain.fina": "\uFC65",
+ "/yeh.medi_heh.medi": "\uFCF1",
+ "/yeh.medi_jeem.medi_yeh.fina": "\uFDAF",
+ "/yeh.medi_meem.fina": "\uFC93",
+ "/yeh.medi_meem.medi": "\uFCF0",
+ "/yeh.medi_meem.medi_meem.fina": "\uFD9C",
+ "/yeh.medi_meem.medi_yeh.fina": "\uFDB0",
+ "/yeh.medi_noon.fina": "\uFC94",
+ "/yeh.medi_reh.fina": "\uFC91",
+ "/yeh.medi_yeh.fina": "\uFC96",
+ "/yeh.medi_zain.fina": "\uFC92",
+ "/yehBarreeDigitThreeAbove": "\u077B",
+ "/yehBarreeDigitTwoAbove": "\u077A",
+ "/yehVabove": "\u06CE",
+ "/yehabove": "\u06E7",
+ "/yeharabic": "\u064A",
+ "/yehbarree": "\u06D2",
+ "/yehbarree.fina": "\uFBAF",
+ "/yehbarree.isol": "\uFBAE",
+ "/yehbarreearabic": "\u06D2",
+ "/yehbarreefinalarabic": "\uFBAF",
+ "/yehbarreehamza": "\u06D3",
+ "/yehbarreehamza.fina": "\uFBB1",
+ "/yehbarreehamza.isol": "\uFBB0",
+ "/yehfarsi": "\u06CC",
+ "/yehfarsi.fina": "\uFBFD",
+ "/yehfarsi.init": "\uFBFE",
+ "/yehfarsi.isol": "\uFBFC",
+ "/yehfarsi.medi": "\uFBFF",
+ "/yehfarsiinvertedV": "\u063D",
+ "/yehfarsithreedotsabove": "\u063F",
+ "/yehfarsitwodotsabove": "\u063E",
+ "/yehfinalarabic": "\uFEF2",
+ "/yehhamza": "\u0626",
+ "/yehhamza.fina": "\uFE8A",
+ "/yehhamza.init": "\uFE8B",
+ "/yehhamza.isol": "\uFE89",
+ "/yehhamza.medi": "\uFE8C",
+ "/yehhamzaabovearabic": "\u0626",
+ "/yehhamzaabovefinalarabic": "\uFE8A",
+ "/yehhamzaaboveinitialarabic": "\uFE8B",
+ "/yehhamzaabovemedialarabic": "\uFE8C",
+ "/yehhighhamza": "\u0678",
+ "/yehinitialarabic": "\uFEF3",
+ "/yehmedialarabic": "\uFEF4",
+ "/yehmeeminitialarabic": "\uFCDD",
+ "/yehmeemisolatedarabic": "\uFC58",
+ "/yehnoonfinalarabic": "\uFC94",
+ "/yehsmall": "\u06E6",
+ "/yehtail": "\u06CD",
+ "/yehthreedotsbelow": "\u06D1",
+ "/yehthreedotsbelowarabic": "\u06D1",
+ "/yekorean": "\u3156",
+ "/yellowHeart": "\u1F49B",
+ "/yen": "\u00A5",
+ "/yenmonospace": "\uFFE5",
+ "/yeokorean": "\u3155",
+ "/yeorinhieuhkorean": "\u3186",
+ "/yerachBenYomo:hb": "\u05AA",
+ "/yerahbenyomohebrew": "\u05AA",
+ "/yerahbenyomolefthebrew": "\u05AA",
+ "/yericyrillic": "\u044B",
+ "/yerudieresiscyrillic": "\u04F9",
+ "/yesieungkorean": "\u3181",
+ "/yesieungpansioskorean": "\u3183",
+ "/yesieungsioskorean": "\u3182",
+ "/yetiv:hb": "\u059A",
+ "/yetivhebrew": "\u059A",
+ "/ygrave": "\u1EF3",
+ "/yhoi": "\u1EF7",
+ "/yhook": "\u01B4",
+ "/yhookabove": "\u1EF7",
+ "/yiarmenian": "\u0575",
+ "/yicyrillic": "\u0457",
+ "/yikorean": "\u3162",
+ "/yintonemod": "\u02EA",
+ "/yinyang": "\u262F",
+ "/yiwnarmenian": "\u0582",
+ "/ylongcyr": "\u044B",
+ "/ylongdieresiscyr": "\u04F9",
+ "/yloop": "\u1EFF",
+ "/ymacron": "\u0233",
+ "/ymonospace": "\uFF59",
+ "/yocirclekatakana": "\u32F5",
+ "/yod": "\u05D9",
+ "/yod:hb": "\u05D9",
+ "/yod_yod:hb": "\u05F2",
+ "/yod_yod_patah:hb": "\uFB1F",
+ "/yoddagesh": "\uFB39",
+ "/yoddageshhebrew": "\uFB39",
+ "/yodhebrew": "\u05D9",
+ "/yodwithdagesh:hb": "\uFB39",
+ "/yodwithhiriq:hb": "\uFB1D",
+ "/yodyodhebrew": "\u05F2",
+ "/yodyodpatahhebrew": "\uFB1F",
+ "/yogh": "\u021D",
+ "/yohiragana": "\u3088",
+ "/yoikorean": "\u3189",
+ "/yokatakana": "\u30E8",
+ "/yokatakanahalfwidth": "\uFF96",
+ "/yokorean": "\u315B",
+ "/yosmallhiragana": "\u3087",
+ "/yosmallkatakana": "\u30E7",
+ "/yosmallkatakanahalfwidth": "\uFF6E",
+ "/yot": "\u03F3",
+ "/yotgreek": "\u03F3",
+ "/yoyaekorean": "\u3188",
+ "/yoyakorean": "\u3187",
+ "/yoyakthai": "\u0E22",
+ "/yoyingthai": "\u0E0D",
+ "/yparen": "\u24B4",
+ "/yparenthesized": "\u24B4",
+ "/ypogegrammeni": "\u037A",
+ "/ypogegrammenigreekcmb": "\u0345",
+ "/yr": "\u01A6",
+ "/yring": "\u1E99",
+ "/ystroke": "\u024F",
+ "/ysuperior": "\u02B8",
+ "/ysupmod": "\u02B8",
+ "/ytilde": "\u1EF9",
+ "/yturned": "\u028E",
+ "/yu.fina": "\uFBDC",
+ "/yu.isol": "\uFBDB",
+ "/yuansquare": "\u3350",
+ "/yucirclekatakana": "\u32F4",
+ "/yucyr": "\u044E",
+ "/yuhiragana": "\u3086",
+ "/yuikorean": "\u318C",
+ "/yukatakana": "\u30E6",
+ "/yukatakanahalfwidth": "\uFF95",
+ "/yukirghiz": "\u06C9",
+ "/yukirghiz.fina": "\uFBE3",
+ "/yukirghiz.isol": "\uFBE2",
+ "/yukorean": "\u3160",
+ "/yukrcyr": "\u0457",
+ "/yusbigcyr": "\u046B",
+ "/yusbigcyrillic": "\u046B",
+ "/yusbigiotifiedcyr": "\u046D",
+ "/yusbigiotifiedcyrillic": "\u046D",
+ "/yuslittlecyr": "\u0467",
+ "/yuslittlecyrillic": "\u0467",
+ "/yuslittleiotifiedcyr": "\u0469",
+ "/yuslittleiotifiedcyrillic": "\u0469",
+ "/yusmallhiragana": "\u3085",
+ "/yusmallkatakana": "\u30E5",
+ "/yusmallkatakanahalfwidth": "\uFF6D",
+ "/yuyekorean": "\u318B",
+ "/yuyeokorean": "\u318A",
+ "/yyabengali": "\u09DF",
+ "/yyadeva": "\u095F",
+ "/z": "\u007A",
+ "/zaarmenian": "\u0566",
+ "/zacute": "\u017A",
+ "/zadeva": "\u095B",
+ "/zagurmukhi": "\u0A5B",
+ "/zah": "\u0638",
+ "/zah.fina": "\uFEC6",
+ "/zah.init": "\uFEC7",
+ "/zah.init_meem.fina": "\uFC28",
+ "/zah.init_meem.medi": "\uFCB9",
+ "/zah.isol": "\uFEC5",
+ "/zah.medi": "\uFEC8",
+ "/zah.medi_meem.medi": "\uFD3B",
+ "/zaharabic": "\u0638",
+ "/zahfinalarabic": "\uFEC6",
+ "/zahinitialarabic": "\uFEC7",
+ "/zahiragana": "\u3056",
+ "/zahmedialarabic": "\uFEC8",
+ "/zain": "\u0632",
+ "/zain.fina": "\uFEB0",
+ "/zain.isol": "\uFEAF",
+ "/zainabove": "\u0617",
+ "/zainarabic": "\u0632",
+ "/zainfinalarabic": "\uFEB0",
+ "/zakatakana": "\u30B6",
+ "/zaqefGadol:hb": "\u0595",
+ "/zaqefQatan:hb": "\u0594",
+ "/zaqefgadolhebrew": "\u0595",
+ "/zaqefqatanhebrew": "\u0594",
+ "/zarqa:hb": "\u0598",
+ "/zarqahebrew": "\u0598",
+ "/zayin": "\u05D6",
+ "/zayin:hb": "\u05D6",
+ "/zayindagesh": "\uFB36",
+ "/zayindageshhebrew": "\uFB36",
+ "/zayinhebrew": "\u05D6",
+ "/zayinwithdagesh:hb": "\uFB36",
+ "/zbopomofo": "\u3117",
+ "/zcaron": "\u017E",
+ "/zcircle": "\u24E9",
+ "/zcircumflex": "\u1E91",
+ "/zcurl": "\u0291",
+ "/zdescender": "\u2C6C",
+ "/zdot": "\u017C",
+ "/zdotaccent": "\u017C",
+ "/zdotbelow": "\u1E93",
+ "/zecyr": "\u0437",
+ "/zecyrillic": "\u0437",
+ "/zedescendercyrillic": "\u0499",
+ "/zedieresiscyr": "\u04DF",
+ "/zedieresiscyrillic": "\u04DF",
+ "/zehiragana": "\u305C",
+ "/zekatakana": "\u30BC",
+ "/zero": "\u0030",
+ "/zero.inferior": "\u2080",
+ "/zero.superior": "\u2070",
+ "/zeroarabic": "\u0660",
+ "/zerobengali": "\u09E6",
+ "/zerocircle": "\u24EA",
+ "/zerocircleblack": "\u24FF",
+ "/zerocomma": "\u1F101",
+ "/zerodeva": "\u0966",
+ "/zerofar": "\u06F0",
+ "/zerofullstop": "\u1F100",
+ "/zerogujarati": "\u0AE6",
+ "/zerogurmukhi": "\u0A66",
+ "/zerohackarabic": "\u0660",
+ "/zeroinferior": "\u2080",
+ "/zeromonospace": "\uFF10",
+ "/zerooldstyle": "\uF730",
+ "/zeropersian": "\u06F0",
+ "/zerosquareabove": "\u06E0",
+ "/zerosuperior": "\u2070",
+ "/zerothai": "\u0E50",
+ "/zerothirds": "\u2189",
+ "/zerowidthjoiner": "\uFEFF",
+ "/zerowidthnobreakspace": "\uFEFF",
+ "/zerowidthnonjoiner": "\u200C",
+ "/zerowidthspace": "\u200B",
+ "/zeta": "\u03B6",
+ "/zetailcyr": "\u0499",
+ "/zhbopomofo": "\u3113",
+ "/zhearmenian": "\u056A",
+ "/zhebrevecyr": "\u04C2",
+ "/zhebrevecyrillic": "\u04C2",
+ "/zhecyr": "\u0436",
+ "/zhecyrillic": "\u0436",
+ "/zhedescendercyrillic": "\u0497",
+ "/zhedieresiscyr": "\u04DD",
+ "/zhedieresiscyrillic": "\u04DD",
+ "/zhetailcyr": "\u0497",
+ "/zhook": "\u0225",
+ "/zihiragana": "\u3058",
+ "/zikatakana": "\u30B8",
+ "/zildefunc": "\u236C",
+ "/zinorhebrew": "\u05AE",
+ "/zjekomicyr": "\u0505",
+ "/zlinebelow": "\u1E95",
+ "/zmonospace": "\uFF5A",
+ "/znotationbagmembership": "\u22FF",
+ "/zohiragana": "\u305E",
+ "/zokatakana": "\u30BE",
+ "/zparen": "\u24B5",
+ "/zparenthesized": "\u24B5",
+ "/zretroflex": "\u0290",
+ "/zretroflexhook": "\u0290",
+ "/zstroke": "\u01B6",
+ "/zswashtail": "\u0240",
+ "/zuhiragana": "\u305A",
+ "/zukatakana": "\u30BA",
+ "/zwarakay": "\u0659",
+ # manually added from
+ # https://github.com/serviceprototypinglab/latex-pdfa/blob/master/glyphtounicode-cmr.tex
+ "/angbracketleftBig": "\u28E8",
+ "/angbracketleftBigg": "\u27E8",
+ "/angbracketleftbig": "\u27E8",
+ "/angbracketleftbigg": "\u27E8",
+ "/angbracketrightBig": "\u27E9",
+ "/angbracketrightBigg": "\u27E9",
+ "/angbracketrightbig": "\u27E9",
+ "/angbracketrightbigg": "\u27E9",
+ "/arrowbt": "\u2193",
+ "/arrowdblbt": "\u21D3",
+ "/arrowdbltp": "\u21D1",
+ "/arrowhookleft": "\u21AA",
+ "/arrowhookright": "\u21A9",
+ "/arrowtp": "\u2191",
+ # diff : "/arrowvertex": "\u23D0",
+ "/arrowvertexdbl": "\uED12",
+ "/backslashBig": "\u005C",
+ "/backslashBigg": "\u005C",
+ "/backslashbig": "\u005C",
+ "/backslashbigg": "\u005C",
+ # diff : "/braceex": "\u23AA",
+ "/bracehtipdownleft": "\uED17",
+ "/bracehtipdownright": "\uED18",
+ "/bracehtipupleft": "\uED19",
+ "/bracehtipupright": "\uED1A",
+ "/braceleftBig": "\u007B",
+ "/braceleftBigg": "\u007B",
+ "/braceleftbig": "\u007B",
+ "/braceleftbigg": "\u007B",
+ # diff : "/braceleftbt": "\u23A9",
+ # diff : "/braceleftmid": "\u23A8",
+ # diff : "/bracelefttp": "\u23A7",
+ "/bracerightBig": "\u007D",
+ "/bracerightBigg": "\u007D",
+ "/bracerightbig": "\u007D",
+ "/bracerightbigg": "\u007D",
+ # diff : "/bracerightbt": "\u23AD",
+ # diff : "/bracerightmid": "\u23AC",
+ # diff : "/bracerighttp": "\u23AB",
+ "/bracketleftBig": "\u005B",
+ "/bracketleftBigg": "\u005B",
+ "/bracketleftbig": "\u005B",
+ "/bracketleftbigg": "\u005B",
+ # diff : "/bracketleftbt": "\u23A3",
+ # diff : "/bracketleftex": "\u23A2",
+ # diff : "/bracketlefttp": "\u23A1",
+ "/bracketrightBig": "\u005D",
+ "/bracketrightBigg": "\u005D",
+ "/bracketrightbig": "\u005D",
+ "/bracketrightbigg": "\u005D",
+ # diff : "/bracketrightbt": "\u23A6",
+ # diff : "/bracketrightex": "\u23A5",
+ # diff : "/bracketrighttp": "\u23A4",
+ "/ceilingleftBig": "\u2308",
+ "/ceilingleftBigg": "\u2308",
+ "/ceilingleftbig": "\u2308",
+ "/ceilingleftbigg": "\u2308",
+ "/ceilingrightBig": "\u2309",
+ "/ceilingrightBigg": "\u2309",
+ "/ceilingrightbig": "\u2309",
+ "/ceilingrightbigg": "\u2309",
+ "/circledotdisplay": "\u2A00",
+ "/circledottext": "\u2A00",
+ "/circlemultiplydisplay": "\u2A02",
+ "/circlemultiplytext": "\u2A02",
+ "/circleplusdisplay": "\u2A01",
+ "/circleplustext": "\u2A01",
+ "/contintegraldisplay": "\u222E",
+ "/contintegraltext": "\u222E",
+ "/coproductdisplay": "\u2210",
+ "/coproducttext": "\u2210",
+ "/floorleftBig": "\u230A",
+ "/floorleftBigg": "\u230A",
+ "/floorleftbig": "\u230A",
+ "/floorleftbigg": "\u230A",
+ "/floorrightBig": "\u230B",
+ "/floorrightBigg": "\u230B",
+ "/floorrightbig": "\u230B",
+ "/floorrightbigg": "\u230B",
+ "/hatwide": "\u02C6",
+ "/hatwider": "\u02C6",
+ "/hatwidest": "\u02C6",
+ "/integraldisplay": "\u222B",
+ "/integraltext": "\u222B",
+ "/intersectiondisplay": "\u22C2",
+ "/intersectiontext": "\u22C2",
+ "/logicalanddisplay": "\u22C0",
+ "/logicalandtext": "\u22C0",
+ "/logicalordisplay": "\u22C1",
+ "/logicalortext": "\u22C1",
+ "/mapsto": "\u21A6",
+ "/parenleftBig": "\u0028",
+ "/parenleftBigg": "\u0028",
+ "/parenleftbig": "\u0028",
+ "/parenleftbigg": "\u0028",
+ # diff : "/parenleftbt": "\u239D",
+ # diff : "/parenleftex": "\u239C",
+ # diff : "/parenlefttp": "\u239B",
+ "/parenrightBig": "\u0029",
+ "/parenrightBigg": "\u0029",
+ "/parenrightbig": "\u0029",
+ "/parenrightbigg": "\u0029",
+ # diff : "/parenrightbt": "\u23A0",
+ # diff : "/parenrightex": "\u239F",
+ # diff : "/parenrighttp": "\u239E",
+ "/productdisplay": "\u220F",
+ "/producttext": "\u220F",
+ "/radicalBig": "\u221A",
+ "/radicalBigg": "\u221A",
+ "/radicalbig": "\u221A",
+ "/radicalbigg": "\u221A",
+ "/radicalbt": "\u221A",
+ "/radicaltp": "\uED6A",
+ "/radicalvertex": "\uED6B",
+ "/slashBig": "\u002F",
+ "/slashBigg": "\u002F",
+ "/slashbig": "\u002F",
+ "/slashbigg": "\u002F",
+ "/summationdisplay": "\u2211",
+ "/summationtext": "\u2211",
+ "/tie": "\u2040",
+ "/tildewide": "\u02DC",
+ "/tildewider": "\u02DC",
+ "/tildewidest": "\u02DC",
+ "/uniondisplay": "\u22C3",
+ "/unionmultidisplay": "\u2A04",
+ "/unionmultitext": "\u2A04",
+ "/unionsqdisplay": "\u2A06",
+ "/unionsqtext": "\u2A06",
+ "/uniontext": "\u22C3",
+ "/vextenddouble": "\uED79",
+ "/vextendsingle": "\u23D0",
+ "/a1": "\u25C1",
+ "/a2": "\u22B4",
+ "/a3": "\u25B7",
+ "/a4": "\u22B5",
+ "/a40": "\u02C2",
+ "/a41": "\u02C3",
+ "/a42": "\u2303",
+ "/a43": "\u2304",
+ "/a48": "\u2127",
+ "/a49": "\u22C8",
+ "/a50": "\u25A1",
+ "/a51": "\u25C7",
+ "/a58": "\u2053",
+ "/a59": "\u219D",
+ "/a60": "\u228F",
+ "/a61": "\u2290",
+ "/d0": "\u2199",
+ "/d1": "\u2199",
+ "/d2": "\u2199",
+ "/d3": "\u2199",
+ "/d4": "\u2199",
+ "/d5": "\u2199",
+ "/d6": "\u2199",
+ "/d7": "\u2193",
+ "/d8": "\u2193",
+ "/d9": "\u2193",
+ "/d10": "\u2193",
+ "/d11": "\u2193",
+ "/d12": "\u2193",
+ "/d13": "\u2193",
+ "/d14": "\u2193",
+ "/d15": "\u2193",
+ "/d16": "\u2193",
+ "/d17": "\u2193",
+ "/d18": "\u2193",
+ "/d19": "\u2193",
+ "/d20": "\u2193",
+ "/d21": "\u2193",
+ "/d22": "\u2193",
+ "/d23": "\u2193",
+ "/d24": "\u2198",
+ "/d25": "\u2198",
+ "/d26": "\u2198",
+ "/d27": "\u2198",
+ "/d28": "\u2198",
+ "/d29": "\u2198",
+ "/d30": "\u2198",
+ "/d31": "\u2198",
+ "/d32": "\u2198",
+ "/d33": "\u2198",
+ "/d34": "\u2198",
+ "/d35": "\u2198",
+ "/d36": "\u2198",
+ "/d37": "\u2198",
+ "/d38": "\u2198",
+ "/d39": "\u2192",
+ "/d40": "\u2192",
+ "/d41": "\u2192",
+ "/d42": "\u2192",
+ "/d43": "\u2192",
+ "/d44": "\u2192",
+ "/d45": "\u2192",
+ "/d46": "\u2192",
+ "/d47": "\u2192",
+ "/d48": "\u2192",
+ "/d49": "\u2192",
+ "/d50": "\u2192",
+ "/d51": "\u2192",
+ "/d52": "\u2192",
+ "/d53": "\u2192",
+ "/d54": "\u2192",
+ "/d55": "\u2192",
+ "/d56": "\u2197",
+ "/d57": "\u2197",
+ "/d58": "\u2197",
+ "/d59": "\u2197",
+ "/d60": "\u2197",
+ "/d61": "\u2197",
+ "/d62": "\u2197",
+ "/d63": "\u2197",
+ "/d64": "\u2197",
+ "/d65": "\u2197",
+ "/d66": "\u2197",
+ "/d67": "\u2197",
+ "/d68": "\u2197",
+ "/d69": "\u2197",
+ "/d70": "\u2197",
+ "/d71": "\u2191",
+ "/d72": "\u2191",
+ "/d73": "\u2191",
+ "/d74": "\u2191",
+ "/d75": "\u2191",
+ "/d76": "\u2191",
+ "/d77": "\u2191",
+ "/d78": "\u2191",
+ "/d79": "\u2191",
+ "/d80": "\u2191",
+ "/d81": "\u2191",
+ "/d82": "\u2191",
+ "/d83": "\u2191",
+ "/d84": "\u2191",
+ "/d85": "\u2191",
+ "/d86": "\u2191",
+ "/d87": "\u2191",
+ "/d88": "\u2196",
+ "/d89": "\u2196",
+ "/d90": "\u2196",
+ "/d91": "\u2196",
+ "/d92": "\u2196",
+ "/d93": "\u2196",
+ "/d94": "\u2196",
+ "/d95": "\u2196",
+ "/d96": "\u2196",
+ "/d97": "\u2196",
+ "/d98": "\u2196",
+ "/d99": "\u2196",
+ "/d100": "\u2196",
+ "/d101": "\u2196",
+ "/d102": "\u2196",
+ "/d103": "\u2190",
+ "/d104": "\u2190",
+ "/d105": "\u2190",
+ "/d106": "\u2190",
+ "/d107": "\u2190",
+ "/d108": "\u2190",
+ "/d109": "\u2190",
+ "/d110": "\u2190",
+ "/d111": "\u2190",
+ "/d112": "\u2190",
+ "/d113": "\u2190",
+ "/d114": "\u2190",
+ "/d115": "\u2190",
+ "/d116": "\u2190",
+ "/d117": "\u2190",
+ "/d118": "\u2190",
+ "/d119": "\u2190",
+ "/d120": "\u2199",
+ "/d121": "\u2199",
+ "/d122": "\u2199",
+ "/d123": "\u2199",
+ "/d124": "\u2199",
+ "/d125": "\u2199",
+ "/d126": "\u2199",
+ "/d127": "\u2199",
+ # manually added from
+ # https://github.com/kohler/lcdf-typetools/blob/master/texglyphlist.txt
+ "/Ifractur": "\u2111",
+ "/FFsmall": "\uF766",
+ "/FFIsmall": "\uF766",
+ "/FFLsmall": "\uF766",
+ "/FIsmall": "\uF766",
+ "/FLsmall": "\uF766",
+ # diff : "/Germandbls": "\u0053",
+ "/Germandblssmall": "\uF773",
+ "/Ng": "\u014A",
+ "/Rfractur": "\u211C",
+ "/SS": "\u0053",
+ "/SSsmall": "\uF773",
+ "/altselector": "\uD802",
+ "/angbracketleft": "\u27E8",
+ "/angbracketright": "\u27E9",
+ "/arrowbothv": "\u2195",
+ "/arrowdblbothv": "\u21D5",
+ "/arrowleftbothalf": "\u21BD",
+ "/arrowlefttophalf": "\u21BC",
+ "/arrownortheast": "\u2197",
+ "/arrownorthwest": "\u2196",
+ "/arrowrightbothalf": "\u21C1",
+ "/arrowrighttophalf": "\u21C0",
+ "/arrowsoutheast": "\u2198",
+ "/arrowsouthwest": "\u2199",
+ "/ascendercompwordmark": "\uD80A",
+ "/asteriskcentered": "\u2217",
+ "/bardbl": "\u2225",
+ "/capitalcompwordmark": "\uD809",
+ "/circlecopyrt": "\u20DD",
+ "/circledivide": "\u2298",
+ "/circleminus": "\u2296",
+ "/coproduct": "\u2A3F",
+ "/ct": "\u0063",
+ "/cwm": "\u200C",
+ "/dblbracketleft": "\u27E6",
+ "/dblbracketright": "\u27E7",
+ # diff : "/diamond": "\u2662",
+ "/diamondmath": "\u22C4",
+ # diff : "/dotlessj": "\u0237",
+ "/emptyslot": "\uD801",
+ "/epsilon1": "\u03F5",
+ "/epsiloninv": "\u03F6",
+ "/equivasymptotic": "\u224D",
+ "/flat": "\u266D",
+ "/follows": "\u227B",
+ "/followsequal": "\u2AB0",
+ "/followsorcurly": "\u227D",
+ "/greatermuch": "\u226B",
+ # diff : "/heart": "\u2661",
+ "/interrobangdown": "\u2E18",
+ "/intersectionsq": "\u2293",
+ "/latticetop": "\u22A4",
+ "/lessmuch": "\u226A",
+ "/longdbls": "\u017F",
+ "/longsh": "\u017F",
+ "/longsi": "\u017F",
+ "/longsl": "\u017F",
+ "/longst": "\uFB05",
+ "/lscript": "\u2113",
+ "/natural": "\u266E",
+ "/negationslash": "\u0338",
+ "/ng": "\u014B",
+ "/owner": "\u220B",
+ "/pertenthousand": "\u2031",
+ # diff : "/phi": "\u03D5",
+ # diff : "/phi1": "\u03C6",
+ "/pi1": "\u03D6",
+ "/precedesequal": "\u2AAF",
+ "/precedesorcurly": "\u227C",
+ "/prime": "\u2032",
+ "/rho1": "\u03F1",
+ "/ringfitted": "\uD80D",
+ "/sharp": "\u266F",
+ "/similarequal": "\u2243",
+ "/slurabove": "\u2322",
+ "/slurbelow": "\u2323",
+ "/st": "\uFB06",
+ "/subsetsqequal": "\u2291",
+ "/supersetsqequal": "\u2292",
+ "/triangle": "\u25B3",
+ "/triangleinv": "\u25BD",
+ "/triangleleft": "\u25C1",
+ # diff : "/triangleright": "\u25B7",
+ "/turnstileleft": "\u22A2",
+ "/turnstileright": "\u22A3",
+ "/twelveudash": "\uD80C",
+ "/unionmulti": "\u228E",
+ "/unionsq": "\u2294",
+ "/vector": "\u20D7",
+ "/visualspace": "\u2423",
+ "/Dbar": "\u0110",
+ "/compwordmark": "\u200C",
+ "/dbar": "\u0111",
+ "/rangedash": "\u2013",
+ "/hyphenchar": "\u002D",
+ "/punctdash": "\u2014",
+ "/visiblespace": "\u2423",
+ "/Yen": "\u00A5",
+ "/anticlockwise": "\u27F2",
+ "/arrowparrleftright": "\u21C6",
+ "/arrowparrrightleft": "\u21C4",
+ "/arrowtailleft": "\u21A2",
+ "/arrowtailright": "\u21A3",
+ "/arrowtripleleft": "\u21DA",
+ "/arrowtripleright": "\u21DB",
+ "/check": "\u2713",
+ "/circleR": "\u00AE",
+ "/circleS": "\u24C8",
+ "/circleasterisk": "\u229B",
+ "/circleequal": "\u229C",
+ "/circlering": "\u229A",
+ "/clockwise": "\u27F3",
+ "/curlyleft": "\u21AB",
+ "/curlyright": "\u21AC",
+ "/dblarrowdwn": "\u21CA",
+ "/dblarrowheadleft": "\u219E",
+ "/dblarrowheadright": "\u21A0",
+ # diff : "/dblarrowup": "\u21C8",
+ "/defines": "\u225C",
+ "/diamondsolid": "\u2666",
+ "/difference": "\u224F",
+ "/downfall": "\u22CE",
+ "/equaldotleftright": "\u2252",
+ "/equaldotrightleft": "\u2253",
+ "/equalorfollows": "\u22DF",
+ # diff : "/equalorgreater": "\u2A96",
+ # diff : "/equalorless": "\u2A95",
+ "/equalsdots": "\u2251",
+ "/followsorequal": "\u227F",
+ "/forcesbar": "\u22AA",
+ # diff : "/fork": "\u22D4",
+ "/geomequivalent": "\u224E",
+ "/greaterdbleqlless": "\u2A8C",
+ "/greaterdblequal": "\u2267",
+ "/greaterlessequal": "\u22DB",
+ "/greaterorapproxeql": "\u2A86",
+ "/greaterorequalslant": "\u2A7E",
+ "/greaterorsimilar": "\u2273",
+ "/harpoondownleft": "\u21C3",
+ "/harpoondownright": "\u21C2",
+ "/harpoonleftright": "\u21CC",
+ "/harpoonrightleft": "\u21CB",
+ "/harpoonupleft": "\u21BF",
+ "/harpoonupright": "\u21BE",
+ "/intercal": "\u22BA",
+ "/lessdbleqlgreater": "\u2A8B",
+ "/lessdblequal": "\u2266",
+ "/lessequalgreater": "\u22DA",
+ "/lessorapproxeql": "\u2A85",
+ "/lessorequalslant": "\u2A7D",
+ "/lessorsimilar": "\u2272",
+ "/maltesecross": "\u2720",
+ "/multiopenleft": "\u22CB",
+ "/multiopenright": "\u22CC",
+ "/orunderscore": "\u22BB",
+ "/perpcorrespond": "\u2A5E",
+ # diff : "/precedesorequal": "\u227E",
+ "/primereverse": "\u2035",
+ "/revasymptequal": "\u22CD",
+ "/revsimilar": "\u223D",
+ "/rightanglene": "\u231D",
+ "/rightanglenw": "\u231C",
+ "/rightanglese": "\u231F",
+ "/rightanglesw": "\u231E",
+ "/satisfies": "\u22A8",
+ "/shiftleft": "\u21B0",
+ "/shiftright": "\u21B1",
+ "/square": "\u25A1",
+ "/squaredot": "\u22A1",
+ "/squareminus": "\u229F",
+ "/squaremultiply": "\u22A0",
+ "/squareplus": "\u229E",
+ "/squaresolid": "\u25A0",
+ "/squiggleleftright": "\u21AD",
+ "/squiggleright": "\u21DD",
+ "/subsetdblequal": "\u2AC5",
+ "/supersetdbl": "\u22D1",
+ "/supersetdblequal": "\u2AC6",
+ "/triangledownsld": "\u25BC",
+ "/triangleleftequal": "\u22B4",
+ "/triangleleftsld": "\u25C0",
+ "/trianglerightequal": "\u22B5",
+ "/trianglerightsld": "\u25B6",
+ "/trianglesolid": "\u25B2",
+ "/uprise": "\u22CF",
+ # diff : "/Digamma": "\u1D7C",
+ "/Finv": "\u2132",
+ "/Gmir": "\u2141",
+ "/Omegainv": "\u2127",
+ "/approxorequal": "\u224A",
+ "/archleftdown": "\u21B6",
+ "/archrightdown": "\u21B7",
+ "/beth": "\u2136",
+ "/daleth": "\u2138",
+ "/dividemultiply": "\u22C7",
+ "/downslope": "\u29F9",
+ "/equalorsimilar": "\u2242",
+ "/follownotdbleqv": "\u2ABA",
+ "/follownotslnteql": "\u2AB6",
+ "/followornoteqvlnt": "\u22E9",
+ "/greaternotdblequal": "\u2A8A",
+ "/greaternotequal": "\u2A88",
+ "/greaterornotdbleql": "\u2269",
+ "/greaterornotequal": "\u2269",
+ "/integerdivide": "\u2216",
+ "/lessnotdblequal": "\u2A89",
+ "/lessnotequal": "\u2A87",
+ "/lessornotdbleql": "\u2268",
+ "/lessornotequal": "\u2268",
+ "/multicloseleft": "\u22C9",
+ "/multicloseright": "\u22CA",
+ "/notapproxequal": "\u2247",
+ "/notarrowboth": "\u21AE",
+ "/notarrowleft": "\u219A",
+ "/notarrowright": "\u219B",
+ "/notbar": "\u2224",
+ "/notdblarrowboth": "\u21CE",
+ "/notdblarrowleft": "\u21CD",
+ "/notdblarrowright": "\u21CF",
+ "/notfollows": "\u2281",
+ "/notfollowsoreql": "\u2AB0",
+ "/notforces": "\u22AE",
+ "/notforcesextra": "\u22AF",
+ "/notgreaterdblequal": "\u2267",
+ "/notgreaterequal": "\u2271",
+ "/notgreaterorslnteql": "\u2A7E",
+ "/notlessdblequal": "\u2266",
+ "/notlessequal": "\u2270",
+ "/notlessorslnteql": "\u2A7D",
+ "/notprecedesoreql": "\u2AAF",
+ "/notsatisfies": "\u22AD",
+ "/notsimilar": "\u2241",
+ "/notsubseteql": "\u2288",
+ "/notsubsetordbleql": "\u2AC5",
+ "/notsubsetoreql": "\u228A",
+ "/notsuperseteql": "\u2289",
+ "/notsupersetordbleql": "\u2AC6",
+ "/notsupersetoreql": "\u228B",
+ "/nottriangeqlleft": "\u22EC",
+ "/nottriangeqlright": "\u22ED",
+ "/nottriangleleft": "\u22EA",
+ "/nottriangleright": "\u22EB",
+ "/notturnstile": "\u22AC",
+ "/planckover2pi": "\u210F",
+ "/planckover2pi1": "\u210F",
+ "/precedenotdbleqv": "\u2AB9",
+ "/precedenotslnteql": "\u2AB5",
+ "/precedeornoteqvlnt": "\u22E8",
+ "/subsetnoteql": "\u228A",
+ "/subsetornotdbleql": "\u2ACB",
+ "/supersetnoteql": "\u228B",
+ "/supersetornotdbleql": "\u2ACC",
+ "/upslope": "\u29F8",
+}
+
+
+def _complete() -> None:
+ for i in range(256):
+ adobe_glyphs[f"/a{i}"] = chr(i)
+ adobe_glyphs["/.notdef"] = "□"
+
+
+_complete()
diff --git a/venv/lib/python3.12/site-packages/pypdf/_codecs/core_fontmetrics.py b/venv/lib/python3.12/site-packages/pypdf/_codecs/core_fontmetrics.py
new file mode 100644
index 0000000..b8d1cc7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_codecs/core_fontmetrics.py
@@ -0,0 +1,4441 @@
+# This file is based upon the 14 core AFM files provided by Adobe/Macromedia at
+# https://download.macromedia.com/pub/developer/opentype/tech-notes/Core14_AFMs.zip
+# The original copyright follows:
+#
+# -----------------------------------------------------------------------------------------------
+# Core 14 AFM Files - ReadMe
+#
+# This file and the 14 PostScript(R) AFM files it accompanies may be used, copied, and
+# distributed for any purpose and without charge, with or without modification, provided that all
+# copyright notices are retained; that the AFM files are not distributed without this file; that
+# all modifications to this file or any of the AFM files are prominently noted in the modified
+# file(s); and that this paragraph is not modified. Adobe Systems has no responsibility or
+# obligation to support the use of the AFM files.
+# -----------------------------------------------------------------------------------------------
+
+
+from pypdf._font import FontDescriptor
+
+CORE_FONT_METRICS: dict[str, FontDescriptor] = {
+ # Generated from Courier.afm
+ # Copyright (c) 1989, 1990, 1991, 1992, 1993, 1997 Adobe Systems Incorporated. All Rights
+ # Reserved.
+ "Courier": FontDescriptor(
+ name="Courier",
+ family="Courier",
+ weight="Medium",
+ ascent=629,
+ descent=-157,
+ cap_height=562,
+ x_height=426,
+ italic_angle=0,
+ flags=33,
+ bbox=(-23.0, -250.0, 715.0, 805.0),
+ character_widths={
+ " ": 600,
+ "!": 600,
+ '"': 600,
+ "#": 600,
+ "$": 600,
+ "%": 600,
+ "&": 600,
+ "\u2019": 600,
+ "(": 600,
+ ")": 600,
+ "*": 600,
+ "+": 600,
+ ",": 600,
+ "-": 600,
+ ".": 600,
+ "/": 600,
+ "0": 600,
+ "1": 600,
+ "2": 600,
+ "3": 600,
+ "4": 600,
+ "5": 600,
+ "6": 600,
+ "7": 600,
+ "8": 600,
+ "9": 600,
+ ":": 600,
+ ";": 600,
+ "<": 600,
+ "=": 600,
+ ">": 600,
+ "?": 600,
+ "@": 600,
+ "A": 600,
+ "B": 600,
+ "C": 600,
+ "D": 600,
+ "E": 600,
+ "F": 600,
+ "G": 600,
+ "H": 600,
+ "I": 600,
+ "J": 600,
+ "K": 600,
+ "L": 600,
+ "M": 600,
+ "N": 600,
+ "O": 600,
+ "P": 600,
+ "Q": 600,
+ "R": 600,
+ "S": 600,
+ "T": 600,
+ "U": 600,
+ "V": 600,
+ "W": 600,
+ "X": 600,
+ "Y": 600,
+ "Z": 600,
+ "[": 600,
+ "\\": 600,
+ "]": 600,
+ "^": 600,
+ "_": 600,
+ "\u2018": 600,
+ "a": 600,
+ "b": 600,
+ "c": 600,
+ "d": 600,
+ "e": 600,
+ "f": 600,
+ "g": 600,
+ "h": 600,
+ "i": 600,
+ "j": 600,
+ "k": 600,
+ "l": 600,
+ "m": 600,
+ "n": 600,
+ "o": 600,
+ "p": 600,
+ "q": 600,
+ "r": 600,
+ "s": 600,
+ "t": 600,
+ "u": 600,
+ "v": 600,
+ "w": 600,
+ "x": 600,
+ "y": 600,
+ "z": 600,
+ "{": 600,
+ "|": 600,
+ "}": 600,
+ "~": 600,
+ "\xa1": 600,
+ "\xa2": 600,
+ "\xa3": 600,
+ "\u2044": 600,
+ "\xa5": 600,
+ "\u0192": 600,
+ "\xa7": 600,
+ "\xa4": 600,
+ "'": 600,
+ "\u201c": 600,
+ "\xab": 600,
+ "\u2039": 600,
+ "\u203a": 600,
+ "\ufb01": 600,
+ "\ufb02": 600,
+ "\u2013": 600,
+ "\u2020": 600,
+ "\u2021": 600,
+ "\xb7": 600,
+ "\xb6": 600,
+ "\u2022": 600,
+ "\u201a": 600,
+ "\u201e": 600,
+ "\u201d": 600,
+ "\xbb": 600,
+ "\u2026": 600,
+ "\u2030": 600,
+ "\xbf": 600,
+ "`": 600,
+ "\xb4": 600,
+ "\u02c6": 600,
+ "\u02dc": 600,
+ "\xaf": 600,
+ "\u02d8": 600,
+ "\u02d9": 600,
+ "\xa8": 600,
+ "\u02da": 600,
+ "\xb8": 600,
+ "\u02dd": 600,
+ "\u02db": 600,
+ "\u02c7": 600,
+ "\u2014": 600,
+ "\xc6": 600,
+ "\xaa": 600,
+ "\u0141": 600,
+ "\xd8": 600,
+ "\u0152": 600,
+ "\xba": 600,
+ "\xe6": 600,
+ "\u0131": 600,
+ "\u0142": 600,
+ "\xf8": 600,
+ "\u0153": 600,
+ "\xdf": 600,
+ "\xcf": 600,
+ "\xe9": 600,
+ "\u0103": 600,
+ "\u0171": 600,
+ "\u011b": 600,
+ "\u0178": 600,
+ "\xf7": 600,
+ "\xdd": 600,
+ "\xc2": 600,
+ "\xe1": 600,
+ "\xdb": 600,
+ "\xfd": 600,
+ "\u0219": 600,
+ "\xea": 600,
+ "\u016e": 600,
+ "\xdc": 600,
+ "\u0105": 600,
+ "\xda": 600,
+ "\u0173": 600,
+ "\xcb": 600,
+ "\u0110": 600,
+ "\uf6c3": 600,
+ "\xa9": 600,
+ "\u0112": 600,
+ "\u010d": 600,
+ "\xe5": 600,
+ "\u0145": 600,
+ "\u013a": 600,
+ "\xe0": 600,
+ "\u0162": 600,
+ "\u0106": 600,
+ "\xe3": 600,
+ "\u0116": 600,
+ "\u0161": 600,
+ "\u015f": 600,
+ "\xed": 600,
+ "\u25ca": 600,
+ "\u0158": 600,
+ "\u0122": 600,
+ "\xfb": 600,
+ "\xe2": 600,
+ "\u0100": 600,
+ "\u0159": 600,
+ "\xe7": 600,
+ "\u017b": 600,
+ "\xde": 600,
+ "\u014c": 600,
+ "\u0154": 600,
+ "\u015a": 600,
+ "\u010f": 600,
+ "\u016a": 600,
+ "\u016f": 600,
+ "\xb3": 600,
+ "\xd2": 600,
+ "\xc0": 600,
+ "\u0102": 600,
+ "\xd7": 600,
+ "\xfa": 600,
+ "\u0164": 600,
+ "\u2202": 600,
+ "\xff": 600,
+ "\u0143": 600,
+ "\xee": 600,
+ "\xca": 600,
+ "\xe4": 600,
+ "\xeb": 600,
+ "\u0107": 600,
+ "\u0144": 600,
+ "\u016b": 600,
+ "\u0147": 600,
+ "\xcd": 600,
+ "\xb1": 600,
+ "\xa6": 600,
+ "\xae": 600,
+ "\u011e": 600,
+ "\u0130": 600,
+ "\u2211": 600,
+ "\xc8": 600,
+ "\u0155": 600,
+ "\u014d": 600,
+ "\u0179": 600,
+ "\u017d": 600,
+ "\u2265": 600,
+ "\xd0": 600,
+ "\xc7": 600,
+ "\u013c": 600,
+ "\u0165": 600,
+ "\u0119": 600,
+ "\u0172": 600,
+ "\xc1": 600,
+ "\xc4": 600,
+ "\xe8": 600,
+ "\u017a": 600,
+ "\u012f": 600,
+ "\xd3": 600,
+ "\xf3": 600,
+ "\u0101": 600,
+ "\u015b": 600,
+ "\xef": 600,
+ "\xd4": 600,
+ "\xd9": 600,
+ "\u2206": 600,
+ "\xfe": 600,
+ "\xb2": 600,
+ "\xd6": 600,
+ "\xb5": 600,
+ "\xec": 600,
+ "\u0151": 600,
+ "\u0118": 600,
+ "\u0111": 600,
+ "\xbe": 600,
+ "\u015e": 600,
+ "\u013e": 600,
+ "\u0136": 600,
+ "\u0139": 600,
+ "\u2122": 600,
+ "\u0117": 600,
+ "\xcc": 600,
+ "\u012a": 600,
+ "\u013d": 600,
+ "\xbd": 600,
+ "\u2264": 600,
+ "\xf4": 600,
+ "\xf1": 600,
+ "\u0170": 600,
+ "\xc9": 600,
+ "\u0113": 600,
+ "\u011f": 600,
+ "\xbc": 600,
+ "\u0160": 600,
+ "\u0218": 600,
+ "\u0150": 600,
+ "\xb0": 600,
+ "\xf2": 600,
+ "\u010c": 600,
+ "\xf9": 600,
+ "\u221a": 600,
+ "\u010e": 600,
+ "\u0157": 600,
+ "\xd1": 600,
+ "\xf5": 600,
+ "\u0156": 600,
+ "\u013b": 600,
+ "\xc3": 600,
+ "\u0104": 600,
+ "\xc5": 600,
+ "\xd5": 600,
+ "\u017c": 600,
+ "\u011a": 600,
+ "\u012e": 600,
+ "\u0137": 600,
+ "\u2212": 600,
+ "\xce": 600,
+ "\u0148": 600,
+ "\u0163": 600,
+ "\xac": 600,
+ "\xf6": 600,
+ "\xfc": 600,
+ "\u2260": 600,
+ "\u0123": 600,
+ "\xf0": 600,
+ "\u017e": 600,
+ "\u0146": 600,
+ "\xb9": 600,
+ "\u012b": 600,
+ "\u20ac": 600,
+ },
+ ),
+ # Generated from Courier-Bold.afm
+ # Copyright (c) 1989, 1990, 1991, 1993, 1997 Adobe Systems Incorporated. All Rights Reserved.
+ "Courier-Bold": FontDescriptor(
+ name="Courier-Bold",
+ family="Courier",
+ weight="Bold",
+ ascent=629,
+ descent=-157,
+ cap_height=562,
+ x_height=439,
+ italic_angle=0,
+ flags=33,
+ bbox=(-113.0, -250.0, 749.0, 801.0),
+ character_widths={
+ " ": 600,
+ "!": 600,
+ '"': 600,
+ "#": 600,
+ "$": 600,
+ "%": 600,
+ "&": 600,
+ "\u2019": 600,
+ "(": 600,
+ ")": 600,
+ "*": 600,
+ "+": 600,
+ ",": 600,
+ "-": 600,
+ ".": 600,
+ "/": 600,
+ "0": 600,
+ "1": 600,
+ "2": 600,
+ "3": 600,
+ "4": 600,
+ "5": 600,
+ "6": 600,
+ "7": 600,
+ "8": 600,
+ "9": 600,
+ ":": 600,
+ ";": 600,
+ "<": 600,
+ "=": 600,
+ ">": 600,
+ "?": 600,
+ "@": 600,
+ "A": 600,
+ "B": 600,
+ "C": 600,
+ "D": 600,
+ "E": 600,
+ "F": 600,
+ "G": 600,
+ "H": 600,
+ "I": 600,
+ "J": 600,
+ "K": 600,
+ "L": 600,
+ "M": 600,
+ "N": 600,
+ "O": 600,
+ "P": 600,
+ "Q": 600,
+ "R": 600,
+ "S": 600,
+ "T": 600,
+ "U": 600,
+ "V": 600,
+ "W": 600,
+ "X": 600,
+ "Y": 600,
+ "Z": 600,
+ "[": 600,
+ "\\": 600,
+ "]": 600,
+ "^": 600,
+ "_": 600,
+ "\u2018": 600,
+ "a": 600,
+ "b": 600,
+ "c": 600,
+ "d": 600,
+ "e": 600,
+ "f": 600,
+ "g": 600,
+ "h": 600,
+ "i": 600,
+ "j": 600,
+ "k": 600,
+ "l": 600,
+ "m": 600,
+ "n": 600,
+ "o": 600,
+ "p": 600,
+ "q": 600,
+ "r": 600,
+ "s": 600,
+ "t": 600,
+ "u": 600,
+ "v": 600,
+ "w": 600,
+ "x": 600,
+ "y": 600,
+ "z": 600,
+ "{": 600,
+ "|": 600,
+ "}": 600,
+ "~": 600,
+ "\xa1": 600,
+ "\xa2": 600,
+ "\xa3": 600,
+ "\u2044": 600,
+ "\xa5": 600,
+ "\u0192": 600,
+ "\xa7": 600,
+ "\xa4": 600,
+ "'": 600,
+ "\u201c": 600,
+ "\xab": 600,
+ "\u2039": 600,
+ "\u203a": 600,
+ "\ufb01": 600,
+ "\ufb02": 600,
+ "\u2013": 600,
+ "\u2020": 600,
+ "\u2021": 600,
+ "\xb7": 600,
+ "\xb6": 600,
+ "\u2022": 600,
+ "\u201a": 600,
+ "\u201e": 600,
+ "\u201d": 600,
+ "\xbb": 600,
+ "\u2026": 600,
+ "\u2030": 600,
+ "\xbf": 600,
+ "`": 600,
+ "\xb4": 600,
+ "\u02c6": 600,
+ "\u02dc": 600,
+ "\xaf": 600,
+ "\u02d8": 600,
+ "\u02d9": 600,
+ "\xa8": 600,
+ "\u02da": 600,
+ "\xb8": 600,
+ "\u02dd": 600,
+ "\u02db": 600,
+ "\u02c7": 600,
+ "\u2014": 600,
+ "\xc6": 600,
+ "\xaa": 600,
+ "\u0141": 600,
+ "\xd8": 600,
+ "\u0152": 600,
+ "\xba": 600,
+ "\xe6": 600,
+ "\u0131": 600,
+ "\u0142": 600,
+ "\xf8": 600,
+ "\u0153": 600,
+ "\xdf": 600,
+ "\xcf": 600,
+ "\xe9": 600,
+ "\u0103": 600,
+ "\u0171": 600,
+ "\u011b": 600,
+ "\u0178": 600,
+ "\xf7": 600,
+ "\xdd": 600,
+ "\xc2": 600,
+ "\xe1": 600,
+ "\xdb": 600,
+ "\xfd": 600,
+ "\u0219": 600,
+ "\xea": 600,
+ "\u016e": 600,
+ "\xdc": 600,
+ "\u0105": 600,
+ "\xda": 600,
+ "\u0173": 600,
+ "\xcb": 600,
+ "\u0110": 600,
+ "\uf6c3": 600,
+ "\xa9": 600,
+ "\u0112": 600,
+ "\u010d": 600,
+ "\xe5": 600,
+ "\u0145": 600,
+ "\u013a": 600,
+ "\xe0": 600,
+ "\u0162": 600,
+ "\u0106": 600,
+ "\xe3": 600,
+ "\u0116": 600,
+ "\u0161": 600,
+ "\u015f": 600,
+ "\xed": 600,
+ "\u25ca": 600,
+ "\u0158": 600,
+ "\u0122": 600,
+ "\xfb": 600,
+ "\xe2": 600,
+ "\u0100": 600,
+ "\u0159": 600,
+ "\xe7": 600,
+ "\u017b": 600,
+ "\xde": 600,
+ "\u014c": 600,
+ "\u0154": 600,
+ "\u015a": 600,
+ "\u010f": 600,
+ "\u016a": 600,
+ "\u016f": 600,
+ "\xb3": 600,
+ "\xd2": 600,
+ "\xc0": 600,
+ "\u0102": 600,
+ "\xd7": 600,
+ "\xfa": 600,
+ "\u0164": 600,
+ "\u2202": 600,
+ "\xff": 600,
+ "\u0143": 600,
+ "\xee": 600,
+ "\xca": 600,
+ "\xe4": 600,
+ "\xeb": 600,
+ "\u0107": 600,
+ "\u0144": 600,
+ "\u016b": 600,
+ "\u0147": 600,
+ "\xcd": 600,
+ "\xb1": 600,
+ "\xa6": 600,
+ "\xae": 600,
+ "\u011e": 600,
+ "\u0130": 600,
+ "\u2211": 600,
+ "\xc8": 600,
+ "\u0155": 600,
+ "\u014d": 600,
+ "\u0179": 600,
+ "\u017d": 600,
+ "\u2265": 600,
+ "\xd0": 600,
+ "\xc7": 600,
+ "\u013c": 600,
+ "\u0165": 600,
+ "\u0119": 600,
+ "\u0172": 600,
+ "\xc1": 600,
+ "\xc4": 600,
+ "\xe8": 600,
+ "\u017a": 600,
+ "\u012f": 600,
+ "\xd3": 600,
+ "\xf3": 600,
+ "\u0101": 600,
+ "\u015b": 600,
+ "\xef": 600,
+ "\xd4": 600,
+ "\xd9": 600,
+ "\u2206": 600,
+ "\xfe": 600,
+ "\xb2": 600,
+ "\xd6": 600,
+ "\xb5": 600,
+ "\xec": 600,
+ "\u0151": 600,
+ "\u0118": 600,
+ "\u0111": 600,
+ "\xbe": 600,
+ "\u015e": 600,
+ "\u013e": 600,
+ "\u0136": 600,
+ "\u0139": 600,
+ "\u2122": 600,
+ "\u0117": 600,
+ "\xcc": 600,
+ "\u012a": 600,
+ "\u013d": 600,
+ "\xbd": 600,
+ "\u2264": 600,
+ "\xf4": 600,
+ "\xf1": 600,
+ "\u0170": 600,
+ "\xc9": 600,
+ "\u0113": 600,
+ "\u011f": 600,
+ "\xbc": 600,
+ "\u0160": 600,
+ "\u0218": 600,
+ "\u0150": 600,
+ "\xb0": 600,
+ "\xf2": 600,
+ "\u010c": 600,
+ "\xf9": 600,
+ "\u221a": 600,
+ "\u010e": 600,
+ "\u0157": 600,
+ "\xd1": 600,
+ "\xf5": 600,
+ "\u0156": 600,
+ "\u013b": 600,
+ "\xc3": 600,
+ "\u0104": 600,
+ "\xc5": 600,
+ "\xd5": 600,
+ "\u017c": 600,
+ "\u011a": 600,
+ "\u012e": 600,
+ "\u0137": 600,
+ "\u2212": 600,
+ "\xce": 600,
+ "\u0148": 600,
+ "\u0163": 600,
+ "\xac": 600,
+ "\xf6": 600,
+ "\xfc": 600,
+ "\u2260": 600,
+ "\u0123": 600,
+ "\xf0": 600,
+ "\u017e": 600,
+ "\u0146": 600,
+ "\xb9": 600,
+ "\u012b": 600,
+ "\u20ac": 600,
+ },
+ ),
+ # Generated from Courier-BoldOblique.afm
+ # Copyright (c) 1989, 1990, 1991, 1993, 1997 Adobe Systems Incorporated. All Rights Reserved.
+ "Courier-BoldOblique": FontDescriptor(
+ name="Courier-BoldOblique",
+ family="Courier",
+ weight="Bold",
+ ascent=629,
+ descent=-157,
+ cap_height=562,
+ x_height=439,
+ italic_angle=-12,
+ flags=97,
+ bbox=(-57.0, -250.0, 869.0, 801.0),
+ character_widths={
+ " ": 600,
+ "!": 600,
+ '"': 600,
+ "#": 600,
+ "$": 600,
+ "%": 600,
+ "&": 600,
+ "\u2019": 600,
+ "(": 600,
+ ")": 600,
+ "*": 600,
+ "+": 600,
+ ",": 600,
+ "-": 600,
+ ".": 600,
+ "/": 600,
+ "0": 600,
+ "1": 600,
+ "2": 600,
+ "3": 600,
+ "4": 600,
+ "5": 600,
+ "6": 600,
+ "7": 600,
+ "8": 600,
+ "9": 600,
+ ":": 600,
+ ";": 600,
+ "<": 600,
+ "=": 600,
+ ">": 600,
+ "?": 600,
+ "@": 600,
+ "A": 600,
+ "B": 600,
+ "C": 600,
+ "D": 600,
+ "E": 600,
+ "F": 600,
+ "G": 600,
+ "H": 600,
+ "I": 600,
+ "J": 600,
+ "K": 600,
+ "L": 600,
+ "M": 600,
+ "N": 600,
+ "O": 600,
+ "P": 600,
+ "Q": 600,
+ "R": 600,
+ "S": 600,
+ "T": 600,
+ "U": 600,
+ "V": 600,
+ "W": 600,
+ "X": 600,
+ "Y": 600,
+ "Z": 600,
+ "[": 600,
+ "\\": 600,
+ "]": 600,
+ "^": 600,
+ "_": 600,
+ "\u2018": 600,
+ "a": 600,
+ "b": 600,
+ "c": 600,
+ "d": 600,
+ "e": 600,
+ "f": 600,
+ "g": 600,
+ "h": 600,
+ "i": 600,
+ "j": 600,
+ "k": 600,
+ "l": 600,
+ "m": 600,
+ "n": 600,
+ "o": 600,
+ "p": 600,
+ "q": 600,
+ "r": 600,
+ "s": 600,
+ "t": 600,
+ "u": 600,
+ "v": 600,
+ "w": 600,
+ "x": 600,
+ "y": 600,
+ "z": 600,
+ "{": 600,
+ "|": 600,
+ "}": 600,
+ "~": 600,
+ "\xa1": 600,
+ "\xa2": 600,
+ "\xa3": 600,
+ "\u2044": 600,
+ "\xa5": 600,
+ "\u0192": 600,
+ "\xa7": 600,
+ "\xa4": 600,
+ "'": 600,
+ "\u201c": 600,
+ "\xab": 600,
+ "\u2039": 600,
+ "\u203a": 600,
+ "\ufb01": 600,
+ "\ufb02": 600,
+ "\u2013": 600,
+ "\u2020": 600,
+ "\u2021": 600,
+ "\xb7": 600,
+ "\xb6": 600,
+ "\u2022": 600,
+ "\u201a": 600,
+ "\u201e": 600,
+ "\u201d": 600,
+ "\xbb": 600,
+ "\u2026": 600,
+ "\u2030": 600,
+ "\xbf": 600,
+ "`": 600,
+ "\xb4": 600,
+ "\u02c6": 600,
+ "\u02dc": 600,
+ "\xaf": 600,
+ "\u02d8": 600,
+ "\u02d9": 600,
+ "\xa8": 600,
+ "\u02da": 600,
+ "\xb8": 600,
+ "\u02dd": 600,
+ "\u02db": 600,
+ "\u02c7": 600,
+ "\u2014": 600,
+ "\xc6": 600,
+ "\xaa": 600,
+ "\u0141": 600,
+ "\xd8": 600,
+ "\u0152": 600,
+ "\xba": 600,
+ "\xe6": 600,
+ "\u0131": 600,
+ "\u0142": 600,
+ "\xf8": 600,
+ "\u0153": 600,
+ "\xdf": 600,
+ "\xcf": 600,
+ "\xe9": 600,
+ "\u0103": 600,
+ "\u0171": 600,
+ "\u011b": 600,
+ "\u0178": 600,
+ "\xf7": 600,
+ "\xdd": 600,
+ "\xc2": 600,
+ "\xe1": 600,
+ "\xdb": 600,
+ "\xfd": 600,
+ "\u0219": 600,
+ "\xea": 600,
+ "\u016e": 600,
+ "\xdc": 600,
+ "\u0105": 600,
+ "\xda": 600,
+ "\u0173": 600,
+ "\xcb": 600,
+ "\u0110": 600,
+ "\uf6c3": 600,
+ "\xa9": 600,
+ "\u0112": 600,
+ "\u010d": 600,
+ "\xe5": 600,
+ "\u0145": 600,
+ "\u013a": 600,
+ "\xe0": 600,
+ "\u0162": 600,
+ "\u0106": 600,
+ "\xe3": 600,
+ "\u0116": 600,
+ "\u0161": 600,
+ "\u015f": 600,
+ "\xed": 600,
+ "\u25ca": 600,
+ "\u0158": 600,
+ "\u0122": 600,
+ "\xfb": 600,
+ "\xe2": 600,
+ "\u0100": 600,
+ "\u0159": 600,
+ "\xe7": 600,
+ "\u017b": 600,
+ "\xde": 600,
+ "\u014c": 600,
+ "\u0154": 600,
+ "\u015a": 600,
+ "\u010f": 600,
+ "\u016a": 600,
+ "\u016f": 600,
+ "\xb3": 600,
+ "\xd2": 600,
+ "\xc0": 600,
+ "\u0102": 600,
+ "\xd7": 600,
+ "\xfa": 600,
+ "\u0164": 600,
+ "\u2202": 600,
+ "\xff": 600,
+ "\u0143": 600,
+ "\xee": 600,
+ "\xca": 600,
+ "\xe4": 600,
+ "\xeb": 600,
+ "\u0107": 600,
+ "\u0144": 600,
+ "\u016b": 600,
+ "\u0147": 600,
+ "\xcd": 600,
+ "\xb1": 600,
+ "\xa6": 600,
+ "\xae": 600,
+ "\u011e": 600,
+ "\u0130": 600,
+ "\u2211": 600,
+ "\xc8": 600,
+ "\u0155": 600,
+ "\u014d": 600,
+ "\u0179": 600,
+ "\u017d": 600,
+ "\u2265": 600,
+ "\xd0": 600,
+ "\xc7": 600,
+ "\u013c": 600,
+ "\u0165": 600,
+ "\u0119": 600,
+ "\u0172": 600,
+ "\xc1": 600,
+ "\xc4": 600,
+ "\xe8": 600,
+ "\u017a": 600,
+ "\u012f": 600,
+ "\xd3": 600,
+ "\xf3": 600,
+ "\u0101": 600,
+ "\u015b": 600,
+ "\xef": 600,
+ "\xd4": 600,
+ "\xd9": 600,
+ "\u2206": 600,
+ "\xfe": 600,
+ "\xb2": 600,
+ "\xd6": 600,
+ "\xb5": 600,
+ "\xec": 600,
+ "\u0151": 600,
+ "\u0118": 600,
+ "\u0111": 600,
+ "\xbe": 600,
+ "\u015e": 600,
+ "\u013e": 600,
+ "\u0136": 600,
+ "\u0139": 600,
+ "\u2122": 600,
+ "\u0117": 600,
+ "\xcc": 600,
+ "\u012a": 600,
+ "\u013d": 600,
+ "\xbd": 600,
+ "\u2264": 600,
+ "\xf4": 600,
+ "\xf1": 600,
+ "\u0170": 600,
+ "\xc9": 600,
+ "\u0113": 600,
+ "\u011f": 600,
+ "\xbc": 600,
+ "\u0160": 600,
+ "\u0218": 600,
+ "\u0150": 600,
+ "\xb0": 600,
+ "\xf2": 600,
+ "\u010c": 600,
+ "\xf9": 600,
+ "\u221a": 600,
+ "\u010e": 600,
+ "\u0157": 600,
+ "\xd1": 600,
+ "\xf5": 600,
+ "\u0156": 600,
+ "\u013b": 600,
+ "\xc3": 600,
+ "\u0104": 600,
+ "\xc5": 600,
+ "\xd5": 600,
+ "\u017c": 600,
+ "\u011a": 600,
+ "\u012e": 600,
+ "\u0137": 600,
+ "\u2212": 600,
+ "\xce": 600,
+ "\u0148": 600,
+ "\u0163": 600,
+ "\xac": 600,
+ "\xf6": 600,
+ "\xfc": 600,
+ "\u2260": 600,
+ "\u0123": 600,
+ "\xf0": 600,
+ "\u017e": 600,
+ "\u0146": 600,
+ "\xb9": 600,
+ "\u012b": 600,
+ "\u20ac": 600,
+ },
+ ),
+ # Generated from Courier-Oblique.afm
+ # Copyright (c) 1989, 1990, 1991, 1992, 1993, 1997 Adobe Systems Incorporated. All Rights
+ # Reserved.
+ "Courier-Oblique": FontDescriptor(
+ name="Courier-Oblique",
+ family="Courier",
+ weight="Medium",
+ ascent=629,
+ descent=-157,
+ cap_height=562,
+ x_height=426,
+ italic_angle=-12,
+ flags=97,
+ bbox=(-27.0, -250.0, 849.0, 805.0),
+ character_widths={
+ " ": 600,
+ "!": 600,
+ '"': 600,
+ "#": 600,
+ "$": 600,
+ "%": 600,
+ "&": 600,
+ "\u2019": 600,
+ "(": 600,
+ ")": 600,
+ "*": 600,
+ "+": 600,
+ ",": 600,
+ "-": 600,
+ ".": 600,
+ "/": 600,
+ "0": 600,
+ "1": 600,
+ "2": 600,
+ "3": 600,
+ "4": 600,
+ "5": 600,
+ "6": 600,
+ "7": 600,
+ "8": 600,
+ "9": 600,
+ ":": 600,
+ ";": 600,
+ "<": 600,
+ "=": 600,
+ ">": 600,
+ "?": 600,
+ "@": 600,
+ "A": 600,
+ "B": 600,
+ "C": 600,
+ "D": 600,
+ "E": 600,
+ "F": 600,
+ "G": 600,
+ "H": 600,
+ "I": 600,
+ "J": 600,
+ "K": 600,
+ "L": 600,
+ "M": 600,
+ "N": 600,
+ "O": 600,
+ "P": 600,
+ "Q": 600,
+ "R": 600,
+ "S": 600,
+ "T": 600,
+ "U": 600,
+ "V": 600,
+ "W": 600,
+ "X": 600,
+ "Y": 600,
+ "Z": 600,
+ "[": 600,
+ "\\": 600,
+ "]": 600,
+ "^": 600,
+ "_": 600,
+ "\u2018": 600,
+ "a": 600,
+ "b": 600,
+ "c": 600,
+ "d": 600,
+ "e": 600,
+ "f": 600,
+ "g": 600,
+ "h": 600,
+ "i": 600,
+ "j": 600,
+ "k": 600,
+ "l": 600,
+ "m": 600,
+ "n": 600,
+ "o": 600,
+ "p": 600,
+ "q": 600,
+ "r": 600,
+ "s": 600,
+ "t": 600,
+ "u": 600,
+ "v": 600,
+ "w": 600,
+ "x": 600,
+ "y": 600,
+ "z": 600,
+ "{": 600,
+ "|": 600,
+ "}": 600,
+ "~": 600,
+ "\xa1": 600,
+ "\xa2": 600,
+ "\xa3": 600,
+ "\u2044": 600,
+ "\xa5": 600,
+ "\u0192": 600,
+ "\xa7": 600,
+ "\xa4": 600,
+ "'": 600,
+ "\u201c": 600,
+ "\xab": 600,
+ "\u2039": 600,
+ "\u203a": 600,
+ "\ufb01": 600,
+ "\ufb02": 600,
+ "\u2013": 600,
+ "\u2020": 600,
+ "\u2021": 600,
+ "\xb7": 600,
+ "\xb6": 600,
+ "\u2022": 600,
+ "\u201a": 600,
+ "\u201e": 600,
+ "\u201d": 600,
+ "\xbb": 600,
+ "\u2026": 600,
+ "\u2030": 600,
+ "\xbf": 600,
+ "`": 600,
+ "\xb4": 600,
+ "\u02c6": 600,
+ "\u02dc": 600,
+ "\xaf": 600,
+ "\u02d8": 600,
+ "\u02d9": 600,
+ "\xa8": 600,
+ "\u02da": 600,
+ "\xb8": 600,
+ "\u02dd": 600,
+ "\u02db": 600,
+ "\u02c7": 600,
+ "\u2014": 600,
+ "\xc6": 600,
+ "\xaa": 600,
+ "\u0141": 600,
+ "\xd8": 600,
+ "\u0152": 600,
+ "\xba": 600,
+ "\xe6": 600,
+ "\u0131": 600,
+ "\u0142": 600,
+ "\xf8": 600,
+ "\u0153": 600,
+ "\xdf": 600,
+ "\xcf": 600,
+ "\xe9": 600,
+ "\u0103": 600,
+ "\u0171": 600,
+ "\u011b": 600,
+ "\u0178": 600,
+ "\xf7": 600,
+ "\xdd": 600,
+ "\xc2": 600,
+ "\xe1": 600,
+ "\xdb": 600,
+ "\xfd": 600,
+ "\u0219": 600,
+ "\xea": 600,
+ "\u016e": 600,
+ "\xdc": 600,
+ "\u0105": 600,
+ "\xda": 600,
+ "\u0173": 600,
+ "\xcb": 600,
+ "\u0110": 600,
+ "\uf6c3": 600,
+ "\xa9": 600,
+ "\u0112": 600,
+ "\u010d": 600,
+ "\xe5": 600,
+ "\u0145": 600,
+ "\u013a": 600,
+ "\xe0": 600,
+ "\u0162": 600,
+ "\u0106": 600,
+ "\xe3": 600,
+ "\u0116": 600,
+ "\u0161": 600,
+ "\u015f": 600,
+ "\xed": 600,
+ "\u25ca": 600,
+ "\u0158": 600,
+ "\u0122": 600,
+ "\xfb": 600,
+ "\xe2": 600,
+ "\u0100": 600,
+ "\u0159": 600,
+ "\xe7": 600,
+ "\u017b": 600,
+ "\xde": 600,
+ "\u014c": 600,
+ "\u0154": 600,
+ "\u015a": 600,
+ "\u010f": 600,
+ "\u016a": 600,
+ "\u016f": 600,
+ "\xb3": 600,
+ "\xd2": 600,
+ "\xc0": 600,
+ "\u0102": 600,
+ "\xd7": 600,
+ "\xfa": 600,
+ "\u0164": 600,
+ "\u2202": 600,
+ "\xff": 600,
+ "\u0143": 600,
+ "\xee": 600,
+ "\xca": 600,
+ "\xe4": 600,
+ "\xeb": 600,
+ "\u0107": 600,
+ "\u0144": 600,
+ "\u016b": 600,
+ "\u0147": 600,
+ "\xcd": 600,
+ "\xb1": 600,
+ "\xa6": 600,
+ "\xae": 600,
+ "\u011e": 600,
+ "\u0130": 600,
+ "\u2211": 600,
+ "\xc8": 600,
+ "\u0155": 600,
+ "\u014d": 600,
+ "\u0179": 600,
+ "\u017d": 600,
+ "\u2265": 600,
+ "\xd0": 600,
+ "\xc7": 600,
+ "\u013c": 600,
+ "\u0165": 600,
+ "\u0119": 600,
+ "\u0172": 600,
+ "\xc1": 600,
+ "\xc4": 600,
+ "\xe8": 600,
+ "\u017a": 600,
+ "\u012f": 600,
+ "\xd3": 600,
+ "\xf3": 600,
+ "\u0101": 600,
+ "\u015b": 600,
+ "\xef": 600,
+ "\xd4": 600,
+ "\xd9": 600,
+ "\u2206": 600,
+ "\xfe": 600,
+ "\xb2": 600,
+ "\xd6": 600,
+ "\xb5": 600,
+ "\xec": 600,
+ "\u0151": 600,
+ "\u0118": 600,
+ "\u0111": 600,
+ "\xbe": 600,
+ "\u015e": 600,
+ "\u013e": 600,
+ "\u0136": 600,
+ "\u0139": 600,
+ "\u2122": 600,
+ "\u0117": 600,
+ "\xcc": 600,
+ "\u012a": 600,
+ "\u013d": 600,
+ "\xbd": 600,
+ "\u2264": 600,
+ "\xf4": 600,
+ "\xf1": 600,
+ "\u0170": 600,
+ "\xc9": 600,
+ "\u0113": 600,
+ "\u011f": 600,
+ "\xbc": 600,
+ "\u0160": 600,
+ "\u0218": 600,
+ "\u0150": 600,
+ "\xb0": 600,
+ "\xf2": 600,
+ "\u010c": 600,
+ "\xf9": 600,
+ "\u221a": 600,
+ "\u010e": 600,
+ "\u0157": 600,
+ "\xd1": 600,
+ "\xf5": 600,
+ "\u0156": 600,
+ "\u013b": 600,
+ "\xc3": 600,
+ "\u0104": 600,
+ "\xc5": 600,
+ "\xd5": 600,
+ "\u017c": 600,
+ "\u011a": 600,
+ "\u012e": 600,
+ "\u0137": 600,
+ "\u2212": 600,
+ "\xce": 600,
+ "\u0148": 600,
+ "\u0163": 600,
+ "\xac": 600,
+ "\xf6": 600,
+ "\xfc": 600,
+ "\u2260": 600,
+ "\u0123": 600,
+ "\xf0": 600,
+ "\u017e": 600,
+ "\u0146": 600,
+ "\xb9": 600,
+ "\u012b": 600,
+ "\u20ac": 600,
+ },
+ ),
+ # Generated from Helvetica.afm
+ # Copyright (c) 1985, 1987, 1989, 1990, 1997 Adobe Systems Incorporated. All Rights Reserved.
+ # Helvetica is a trademark of Linotype-Hell AG and/or its subsidiaries.
+ "Helvetica": FontDescriptor(
+ name="Helvetica",
+ family="Helvetica",
+ weight="Medium",
+ ascent=718,
+ descent=-207,
+ cap_height=718,
+ x_height=523,
+ italic_angle=0,
+ flags=32,
+ bbox=(-166.0, -225.0, 1000.0, 931.0),
+ character_widths={
+ " ": 278,
+ "!": 278,
+ '"': 355,
+ "#": 556,
+ "$": 556,
+ "%": 889,
+ "&": 667,
+ "\u2019": 222,
+ "(": 333,
+ ")": 333,
+ "*": 389,
+ "+": 584,
+ ",": 278,
+ "-": 333,
+ ".": 278,
+ "/": 278,
+ "0": 556,
+ "1": 556,
+ "2": 556,
+ "3": 556,
+ "4": 556,
+ "5": 556,
+ "6": 556,
+ "7": 556,
+ "8": 556,
+ "9": 556,
+ ":": 278,
+ ";": 278,
+ "<": 584,
+ "=": 584,
+ ">": 584,
+ "?": 556,
+ "@": 1015,
+ "A": 667,
+ "B": 667,
+ "C": 722,
+ "D": 722,
+ "E": 667,
+ "F": 611,
+ "G": 778,
+ "H": 722,
+ "I": 278,
+ "J": 500,
+ "K": 667,
+ "L": 556,
+ "M": 833,
+ "N": 722,
+ "O": 778,
+ "P": 667,
+ "Q": 778,
+ "R": 722,
+ "S": 667,
+ "T": 611,
+ "U": 722,
+ "V": 667,
+ "W": 944,
+ "X": 667,
+ "Y": 667,
+ "Z": 611,
+ "[": 278,
+ "\\": 278,
+ "]": 278,
+ "^": 469,
+ "_": 556,
+ "\u2018": 222,
+ "a": 556,
+ "b": 556,
+ "c": 500,
+ "d": 556,
+ "e": 556,
+ "f": 278,
+ "g": 556,
+ "h": 556,
+ "i": 222,
+ "j": 222,
+ "k": 500,
+ "l": 222,
+ "m": 833,
+ "n": 556,
+ "o": 556,
+ "p": 556,
+ "q": 556,
+ "r": 333,
+ "s": 500,
+ "t": 278,
+ "u": 556,
+ "v": 500,
+ "w": 722,
+ "x": 500,
+ "y": 500,
+ "z": 500,
+ "{": 334,
+ "|": 260,
+ "}": 334,
+ "~": 584,
+ "\xa1": 333,
+ "\xa2": 556,
+ "\xa3": 556,
+ "\u2044": 167,
+ "\xa5": 556,
+ "\u0192": 556,
+ "\xa7": 556,
+ "\xa4": 556,
+ "'": 191,
+ "\u201c": 333,
+ "\xab": 556,
+ "\u2039": 333,
+ "\u203a": 333,
+ "\ufb01": 500,
+ "\ufb02": 500,
+ "\u2013": 556,
+ "\u2020": 556,
+ "\u2021": 556,
+ "\xb7": 278,
+ "\xb6": 537,
+ "\u2022": 350,
+ "\u201a": 222,
+ "\u201e": 333,
+ "\u201d": 333,
+ "\xbb": 556,
+ "\u2026": 1000,
+ "\u2030": 1000,
+ "\xbf": 611,
+ "`": 333,
+ "\xb4": 333,
+ "\u02c6": 333,
+ "\u02dc": 333,
+ "\xaf": 333,
+ "\u02d8": 333,
+ "\u02d9": 333,
+ "\xa8": 333,
+ "\u02da": 333,
+ "\xb8": 333,
+ "\u02dd": 333,
+ "\u02db": 333,
+ "\u02c7": 333,
+ "\u2014": 1000,
+ "\xc6": 1000,
+ "\xaa": 370,
+ "\u0141": 556,
+ "\xd8": 778,
+ "\u0152": 1000,
+ "\xba": 365,
+ "\xe6": 889,
+ "\u0131": 278,
+ "\u0142": 222,
+ "\xf8": 611,
+ "\u0153": 944,
+ "\xdf": 611,
+ "\xcf": 278,
+ "\xe9": 556,
+ "\u0103": 556,
+ "\u0171": 556,
+ "\u011b": 556,
+ "\u0178": 667,
+ "\xf7": 584,
+ "\xdd": 667,
+ "\xc2": 667,
+ "\xe1": 556,
+ "\xdb": 722,
+ "\xfd": 500,
+ "\u0219": 500,
+ "\xea": 556,
+ "\u016e": 722,
+ "\xdc": 722,
+ "\u0105": 556,
+ "\xda": 722,
+ "\u0173": 556,
+ "\xcb": 667,
+ "\u0110": 722,
+ "\uf6c3": 250,
+ "\xa9": 737,
+ "\u0112": 667,
+ "\u010d": 500,
+ "\xe5": 556,
+ "\u0145": 722,
+ "\u013a": 222,
+ "\xe0": 556,
+ "\u0162": 611,
+ "\u0106": 722,
+ "\xe3": 556,
+ "\u0116": 667,
+ "\u0161": 500,
+ "\u015f": 500,
+ "\xed": 278,
+ "\u25ca": 471,
+ "\u0158": 722,
+ "\u0122": 778,
+ "\xfb": 556,
+ "\xe2": 556,
+ "\u0100": 667,
+ "\u0159": 333,
+ "\xe7": 500,
+ "\u017b": 611,
+ "\xde": 667,
+ "\u014c": 778,
+ "\u0154": 722,
+ "\u015a": 667,
+ "\u010f": 643,
+ "\u016a": 722,
+ "\u016f": 556,
+ "\xb3": 333,
+ "\xd2": 778,
+ "\xc0": 667,
+ "\u0102": 667,
+ "\xd7": 584,
+ "\xfa": 556,
+ "\u0164": 611,
+ "\u2202": 476,
+ "\xff": 500,
+ "\u0143": 722,
+ "\xee": 278,
+ "\xca": 667,
+ "\xe4": 556,
+ "\xeb": 556,
+ "\u0107": 500,
+ "\u0144": 556,
+ "\u016b": 556,
+ "\u0147": 722,
+ "\xcd": 278,
+ "\xb1": 584,
+ "\xa6": 260,
+ "\xae": 737,
+ "\u011e": 778,
+ "\u0130": 278,
+ "\u2211": 600,
+ "\xc8": 667,
+ "\u0155": 333,
+ "\u014d": 556,
+ "\u0179": 611,
+ "\u017d": 611,
+ "\u2265": 549,
+ "\xd0": 722,
+ "\xc7": 722,
+ "\u013c": 222,
+ "\u0165": 317,
+ "\u0119": 556,
+ "\u0172": 722,
+ "\xc1": 667,
+ "\xc4": 667,
+ "\xe8": 556,
+ "\u017a": 500,
+ "\u012f": 222,
+ "\xd3": 778,
+ "\xf3": 556,
+ "\u0101": 556,
+ "\u015b": 500,
+ "\xef": 278,
+ "\xd4": 778,
+ "\xd9": 722,
+ "\u2206": 612,
+ "\xfe": 556,
+ "\xb2": 333,
+ "\xd6": 778,
+ "\xb5": 556,
+ "\xec": 278,
+ "\u0151": 556,
+ "\u0118": 667,
+ "\u0111": 556,
+ "\xbe": 834,
+ "\u015e": 667,
+ "\u013e": 299,
+ "\u0136": 667,
+ "\u0139": 556,
+ "\u2122": 1000,
+ "\u0117": 556,
+ "\xcc": 278,
+ "\u012a": 278,
+ "\u013d": 556,
+ "\xbd": 834,
+ "\u2264": 549,
+ "\xf4": 556,
+ "\xf1": 556,
+ "\u0170": 722,
+ "\xc9": 667,
+ "\u0113": 556,
+ "\u011f": 556,
+ "\xbc": 834,
+ "\u0160": 667,
+ "\u0218": 667,
+ "\u0150": 778,
+ "\xb0": 400,
+ "\xf2": 556,
+ "\u010c": 722,
+ "\xf9": 556,
+ "\u221a": 453,
+ "\u010e": 722,
+ "\u0157": 333,
+ "\xd1": 722,
+ "\xf5": 556,
+ "\u0156": 722,
+ "\u013b": 556,
+ "\xc3": 667,
+ "\u0104": 667,
+ "\xc5": 667,
+ "\xd5": 778,
+ "\u017c": 500,
+ "\u011a": 667,
+ "\u012e": 278,
+ "\u0137": 500,
+ "\u2212": 584,
+ "\xce": 278,
+ "\u0148": 556,
+ "\u0163": 278,
+ "\xac": 584,
+ "\xf6": 556,
+ "\xfc": 556,
+ "\u2260": 549,
+ "\u0123": 556,
+ "\xf0": 556,
+ "\u017e": 500,
+ "\u0146": 556,
+ "\xb9": 333,
+ "\u012b": 278,
+ "\u20ac": 556,
+ },
+ ),
+ # Generated from Helvetica-Bold.afm
+ # Copyright (c) 1985, 1987, 1989, 1990, 1997 Adobe Systems Incorporated. All Rights Reserved.
+ # Helvetica is a trademark of Linotype-Hell AG and/or its subsidiaries.
+ "Helvetica-Bold": FontDescriptor(
+ name="Helvetica-Bold",
+ family="Helvetica",
+ weight="Bold",
+ ascent=718,
+ descent=-207,
+ cap_height=718,
+ x_height=532,
+ italic_angle=0,
+ flags=32,
+ bbox=(-170.0, -228.0, 1003.0, 962.0),
+ character_widths={
+ " ": 278,
+ "!": 333,
+ '"': 474,
+ "#": 556,
+ "$": 556,
+ "%": 889,
+ "&": 722,
+ "\u2019": 278,
+ "(": 333,
+ ")": 333,
+ "*": 389,
+ "+": 584,
+ ",": 278,
+ "-": 333,
+ ".": 278,
+ "/": 278,
+ "0": 556,
+ "1": 556,
+ "2": 556,
+ "3": 556,
+ "4": 556,
+ "5": 556,
+ "6": 556,
+ "7": 556,
+ "8": 556,
+ "9": 556,
+ ":": 333,
+ ";": 333,
+ "<": 584,
+ "=": 584,
+ ">": 584,
+ "?": 611,
+ "@": 975,
+ "A": 722,
+ "B": 722,
+ "C": 722,
+ "D": 722,
+ "E": 667,
+ "F": 611,
+ "G": 778,
+ "H": 722,
+ "I": 278,
+ "J": 556,
+ "K": 722,
+ "L": 611,
+ "M": 833,
+ "N": 722,
+ "O": 778,
+ "P": 667,
+ "Q": 778,
+ "R": 722,
+ "S": 667,
+ "T": 611,
+ "U": 722,
+ "V": 667,
+ "W": 944,
+ "X": 667,
+ "Y": 667,
+ "Z": 611,
+ "[": 333,
+ "\\": 278,
+ "]": 333,
+ "^": 584,
+ "_": 556,
+ "\u2018": 278,
+ "a": 556,
+ "b": 611,
+ "c": 556,
+ "d": 611,
+ "e": 556,
+ "f": 333,
+ "g": 611,
+ "h": 611,
+ "i": 278,
+ "j": 278,
+ "k": 556,
+ "l": 278,
+ "m": 889,
+ "n": 611,
+ "o": 611,
+ "p": 611,
+ "q": 611,
+ "r": 389,
+ "s": 556,
+ "t": 333,
+ "u": 611,
+ "v": 556,
+ "w": 778,
+ "x": 556,
+ "y": 556,
+ "z": 500,
+ "{": 389,
+ "|": 280,
+ "}": 389,
+ "~": 584,
+ "\xa1": 333,
+ "\xa2": 556,
+ "\xa3": 556,
+ "\u2044": 167,
+ "\xa5": 556,
+ "\u0192": 556,
+ "\xa7": 556,
+ "\xa4": 556,
+ "'": 238,
+ "\u201c": 500,
+ "\xab": 556,
+ "\u2039": 333,
+ "\u203a": 333,
+ "\ufb01": 611,
+ "\ufb02": 611,
+ "\u2013": 556,
+ "\u2020": 556,
+ "\u2021": 556,
+ "\xb7": 278,
+ "\xb6": 556,
+ "\u2022": 350,
+ "\u201a": 278,
+ "\u201e": 500,
+ "\u201d": 500,
+ "\xbb": 556,
+ "\u2026": 1000,
+ "\u2030": 1000,
+ "\xbf": 611,
+ "`": 333,
+ "\xb4": 333,
+ "\u02c6": 333,
+ "\u02dc": 333,
+ "\xaf": 333,
+ "\u02d8": 333,
+ "\u02d9": 333,
+ "\xa8": 333,
+ "\u02da": 333,
+ "\xb8": 333,
+ "\u02dd": 333,
+ "\u02db": 333,
+ "\u02c7": 333,
+ "\u2014": 1000,
+ "\xc6": 1000,
+ "\xaa": 370,
+ "\u0141": 611,
+ "\xd8": 778,
+ "\u0152": 1000,
+ "\xba": 365,
+ "\xe6": 889,
+ "\u0131": 278,
+ "\u0142": 278,
+ "\xf8": 611,
+ "\u0153": 944,
+ "\xdf": 611,
+ "\xcf": 278,
+ "\xe9": 556,
+ "\u0103": 556,
+ "\u0171": 611,
+ "\u011b": 556,
+ "\u0178": 667,
+ "\xf7": 584,
+ "\xdd": 667,
+ "\xc2": 722,
+ "\xe1": 556,
+ "\xdb": 722,
+ "\xfd": 556,
+ "\u0219": 556,
+ "\xea": 556,
+ "\u016e": 722,
+ "\xdc": 722,
+ "\u0105": 556,
+ "\xda": 722,
+ "\u0173": 611,
+ "\xcb": 667,
+ "\u0110": 722,
+ "\uf6c3": 250,
+ "\xa9": 737,
+ "\u0112": 667,
+ "\u010d": 556,
+ "\xe5": 556,
+ "\u0145": 722,
+ "\u013a": 278,
+ "\xe0": 556,
+ "\u0162": 611,
+ "\u0106": 722,
+ "\xe3": 556,
+ "\u0116": 667,
+ "\u0161": 556,
+ "\u015f": 556,
+ "\xed": 278,
+ "\u25ca": 494,
+ "\u0158": 722,
+ "\u0122": 778,
+ "\xfb": 611,
+ "\xe2": 556,
+ "\u0100": 722,
+ "\u0159": 389,
+ "\xe7": 556,
+ "\u017b": 611,
+ "\xde": 667,
+ "\u014c": 778,
+ "\u0154": 722,
+ "\u015a": 667,
+ "\u010f": 743,
+ "\u016a": 722,
+ "\u016f": 611,
+ "\xb3": 333,
+ "\xd2": 778,
+ "\xc0": 722,
+ "\u0102": 722,
+ "\xd7": 584,
+ "\xfa": 611,
+ "\u0164": 611,
+ "\u2202": 494,
+ "\xff": 556,
+ "\u0143": 722,
+ "\xee": 278,
+ "\xca": 667,
+ "\xe4": 556,
+ "\xeb": 556,
+ "\u0107": 556,
+ "\u0144": 611,
+ "\u016b": 611,
+ "\u0147": 722,
+ "\xcd": 278,
+ "\xb1": 584,
+ "\xa6": 280,
+ "\xae": 737,
+ "\u011e": 778,
+ "\u0130": 278,
+ "\u2211": 600,
+ "\xc8": 667,
+ "\u0155": 389,
+ "\u014d": 611,
+ "\u0179": 611,
+ "\u017d": 611,
+ "\u2265": 549,
+ "\xd0": 722,
+ "\xc7": 722,
+ "\u013c": 278,
+ "\u0165": 389,
+ "\u0119": 556,
+ "\u0172": 722,
+ "\xc1": 722,
+ "\xc4": 722,
+ "\xe8": 556,
+ "\u017a": 500,
+ "\u012f": 278,
+ "\xd3": 778,
+ "\xf3": 611,
+ "\u0101": 556,
+ "\u015b": 556,
+ "\xef": 278,
+ "\xd4": 778,
+ "\xd9": 722,
+ "\u2206": 612,
+ "\xfe": 611,
+ "\xb2": 333,
+ "\xd6": 778,
+ "\xb5": 611,
+ "\xec": 278,
+ "\u0151": 611,
+ "\u0118": 667,
+ "\u0111": 611,
+ "\xbe": 834,
+ "\u015e": 667,
+ "\u013e": 400,
+ "\u0136": 722,
+ "\u0139": 611,
+ "\u2122": 1000,
+ "\u0117": 556,
+ "\xcc": 278,
+ "\u012a": 278,
+ "\u013d": 611,
+ "\xbd": 834,
+ "\u2264": 549,
+ "\xf4": 611,
+ "\xf1": 611,
+ "\u0170": 722,
+ "\xc9": 667,
+ "\u0113": 556,
+ "\u011f": 611,
+ "\xbc": 834,
+ "\u0160": 667,
+ "\u0218": 667,
+ "\u0150": 778,
+ "\xb0": 400,
+ "\xf2": 611,
+ "\u010c": 722,
+ "\xf9": 611,
+ "\u221a": 549,
+ "\u010e": 722,
+ "\u0157": 389,
+ "\xd1": 722,
+ "\xf5": 611,
+ "\u0156": 722,
+ "\u013b": 611,
+ "\xc3": 722,
+ "\u0104": 722,
+ "\xc5": 722,
+ "\xd5": 778,
+ "\u017c": 500,
+ "\u011a": 667,
+ "\u012e": 278,
+ "\u0137": 556,
+ "\u2212": 584,
+ "\xce": 278,
+ "\u0148": 611,
+ "\u0163": 333,
+ "\xac": 584,
+ "\xf6": 611,
+ "\xfc": 611,
+ "\u2260": 549,
+ "\u0123": 611,
+ "\xf0": 611,
+ "\u017e": 500,
+ "\u0146": 611,
+ "\xb9": 333,
+ "\u012b": 278,
+ "\u20ac": 556,
+ },
+ ),
+ # Generated from Helvetica-BoldOblique.afm
+ # Copyright (c) 1985, 1987, 1989, 1990, 1997 Adobe Systems Incorporated. All Rights Reserved.
+ # Helvetica is a trademark of Linotype-Hell AG and/or its subsidiaries.
+ "Helvetica-BoldOblique": FontDescriptor(
+ name="Helvetica-BoldOblique",
+ family="Helvetica",
+ weight="Bold",
+ ascent=718,
+ descent=-207,
+ cap_height=718,
+ x_height=532,
+ italic_angle=-12,
+ flags=96,
+ bbox=(-174.0, -228.0, 1114.0, 962.0),
+ character_widths={
+ " ": 278,
+ "!": 333,
+ '"': 474,
+ "#": 556,
+ "$": 556,
+ "%": 889,
+ "&": 722,
+ "\u2019": 278,
+ "(": 333,
+ ")": 333,
+ "*": 389,
+ "+": 584,
+ ",": 278,
+ "-": 333,
+ ".": 278,
+ "/": 278,
+ "0": 556,
+ "1": 556,
+ "2": 556,
+ "3": 556,
+ "4": 556,
+ "5": 556,
+ "6": 556,
+ "7": 556,
+ "8": 556,
+ "9": 556,
+ ":": 333,
+ ";": 333,
+ "<": 584,
+ "=": 584,
+ ">": 584,
+ "?": 611,
+ "@": 975,
+ "A": 722,
+ "B": 722,
+ "C": 722,
+ "D": 722,
+ "E": 667,
+ "F": 611,
+ "G": 778,
+ "H": 722,
+ "I": 278,
+ "J": 556,
+ "K": 722,
+ "L": 611,
+ "M": 833,
+ "N": 722,
+ "O": 778,
+ "P": 667,
+ "Q": 778,
+ "R": 722,
+ "S": 667,
+ "T": 611,
+ "U": 722,
+ "V": 667,
+ "W": 944,
+ "X": 667,
+ "Y": 667,
+ "Z": 611,
+ "[": 333,
+ "\\": 278,
+ "]": 333,
+ "^": 584,
+ "_": 556,
+ "\u2018": 278,
+ "a": 556,
+ "b": 611,
+ "c": 556,
+ "d": 611,
+ "e": 556,
+ "f": 333,
+ "g": 611,
+ "h": 611,
+ "i": 278,
+ "j": 278,
+ "k": 556,
+ "l": 278,
+ "m": 889,
+ "n": 611,
+ "o": 611,
+ "p": 611,
+ "q": 611,
+ "r": 389,
+ "s": 556,
+ "t": 333,
+ "u": 611,
+ "v": 556,
+ "w": 778,
+ "x": 556,
+ "y": 556,
+ "z": 500,
+ "{": 389,
+ "|": 280,
+ "}": 389,
+ "~": 584,
+ "\xa1": 333,
+ "\xa2": 556,
+ "\xa3": 556,
+ "\u2044": 167,
+ "\xa5": 556,
+ "\u0192": 556,
+ "\xa7": 556,
+ "\xa4": 556,
+ "'": 238,
+ "\u201c": 500,
+ "\xab": 556,
+ "\u2039": 333,
+ "\u203a": 333,
+ "\ufb01": 611,
+ "\ufb02": 611,
+ "\u2013": 556,
+ "\u2020": 556,
+ "\u2021": 556,
+ "\xb7": 278,
+ "\xb6": 556,
+ "\u2022": 350,
+ "\u201a": 278,
+ "\u201e": 500,
+ "\u201d": 500,
+ "\xbb": 556,
+ "\u2026": 1000,
+ "\u2030": 1000,
+ "\xbf": 611,
+ "`": 333,
+ "\xb4": 333,
+ "\u02c6": 333,
+ "\u02dc": 333,
+ "\xaf": 333,
+ "\u02d8": 333,
+ "\u02d9": 333,
+ "\xa8": 333,
+ "\u02da": 333,
+ "\xb8": 333,
+ "\u02dd": 333,
+ "\u02db": 333,
+ "\u02c7": 333,
+ "\u2014": 1000,
+ "\xc6": 1000,
+ "\xaa": 370,
+ "\u0141": 611,
+ "\xd8": 778,
+ "\u0152": 1000,
+ "\xba": 365,
+ "\xe6": 889,
+ "\u0131": 278,
+ "\u0142": 278,
+ "\xf8": 611,
+ "\u0153": 944,
+ "\xdf": 611,
+ "\xcf": 278,
+ "\xe9": 556,
+ "\u0103": 556,
+ "\u0171": 611,
+ "\u011b": 556,
+ "\u0178": 667,
+ "\xf7": 584,
+ "\xdd": 667,
+ "\xc2": 722,
+ "\xe1": 556,
+ "\xdb": 722,
+ "\xfd": 556,
+ "\u0219": 556,
+ "\xea": 556,
+ "\u016e": 722,
+ "\xdc": 722,
+ "\u0105": 556,
+ "\xda": 722,
+ "\u0173": 611,
+ "\xcb": 667,
+ "\u0110": 722,
+ "\uf6c3": 250,
+ "\xa9": 737,
+ "\u0112": 667,
+ "\u010d": 556,
+ "\xe5": 556,
+ "\u0145": 722,
+ "\u013a": 278,
+ "\xe0": 556,
+ "\u0162": 611,
+ "\u0106": 722,
+ "\xe3": 556,
+ "\u0116": 667,
+ "\u0161": 556,
+ "\u015f": 556,
+ "\xed": 278,
+ "\u25ca": 494,
+ "\u0158": 722,
+ "\u0122": 778,
+ "\xfb": 611,
+ "\xe2": 556,
+ "\u0100": 722,
+ "\u0159": 389,
+ "\xe7": 556,
+ "\u017b": 611,
+ "\xde": 667,
+ "\u014c": 778,
+ "\u0154": 722,
+ "\u015a": 667,
+ "\u010f": 743,
+ "\u016a": 722,
+ "\u016f": 611,
+ "\xb3": 333,
+ "\xd2": 778,
+ "\xc0": 722,
+ "\u0102": 722,
+ "\xd7": 584,
+ "\xfa": 611,
+ "\u0164": 611,
+ "\u2202": 494,
+ "\xff": 556,
+ "\u0143": 722,
+ "\xee": 278,
+ "\xca": 667,
+ "\xe4": 556,
+ "\xeb": 556,
+ "\u0107": 556,
+ "\u0144": 611,
+ "\u016b": 611,
+ "\u0147": 722,
+ "\xcd": 278,
+ "\xb1": 584,
+ "\xa6": 280,
+ "\xae": 737,
+ "\u011e": 778,
+ "\u0130": 278,
+ "\u2211": 600,
+ "\xc8": 667,
+ "\u0155": 389,
+ "\u014d": 611,
+ "\u0179": 611,
+ "\u017d": 611,
+ "\u2265": 549,
+ "\xd0": 722,
+ "\xc7": 722,
+ "\u013c": 278,
+ "\u0165": 389,
+ "\u0119": 556,
+ "\u0172": 722,
+ "\xc1": 722,
+ "\xc4": 722,
+ "\xe8": 556,
+ "\u017a": 500,
+ "\u012f": 278,
+ "\xd3": 778,
+ "\xf3": 611,
+ "\u0101": 556,
+ "\u015b": 556,
+ "\xef": 278,
+ "\xd4": 778,
+ "\xd9": 722,
+ "\u2206": 612,
+ "\xfe": 611,
+ "\xb2": 333,
+ "\xd6": 778,
+ "\xb5": 611,
+ "\xec": 278,
+ "\u0151": 611,
+ "\u0118": 667,
+ "\u0111": 611,
+ "\xbe": 834,
+ "\u015e": 667,
+ "\u013e": 400,
+ "\u0136": 722,
+ "\u0139": 611,
+ "\u2122": 1000,
+ "\u0117": 556,
+ "\xcc": 278,
+ "\u012a": 278,
+ "\u013d": 611,
+ "\xbd": 834,
+ "\u2264": 549,
+ "\xf4": 611,
+ "\xf1": 611,
+ "\u0170": 722,
+ "\xc9": 667,
+ "\u0113": 556,
+ "\u011f": 611,
+ "\xbc": 834,
+ "\u0160": 667,
+ "\u0218": 667,
+ "\u0150": 778,
+ "\xb0": 400,
+ "\xf2": 611,
+ "\u010c": 722,
+ "\xf9": 611,
+ "\u221a": 549,
+ "\u010e": 722,
+ "\u0157": 389,
+ "\xd1": 722,
+ "\xf5": 611,
+ "\u0156": 722,
+ "\u013b": 611,
+ "\xc3": 722,
+ "\u0104": 722,
+ "\xc5": 722,
+ "\xd5": 778,
+ "\u017c": 500,
+ "\u011a": 667,
+ "\u012e": 278,
+ "\u0137": 556,
+ "\u2212": 584,
+ "\xce": 278,
+ "\u0148": 611,
+ "\u0163": 333,
+ "\xac": 584,
+ "\xf6": 611,
+ "\xfc": 611,
+ "\u2260": 549,
+ "\u0123": 611,
+ "\xf0": 611,
+ "\u017e": 500,
+ "\u0146": 611,
+ "\xb9": 333,
+ "\u012b": 278,
+ "\u20ac": 556,
+ },
+ ),
+ # Generated from Helvetica-Oblique.afm
+ # Copyright (c) 1985, 1987, 1989, 1990, 1997 Adobe Systems Incorporated. All Rights Reserved.
+ # Helvetica is a trademark of Linotype-Hell AG and/or its subsidiaries.
+ "Helvetica-Oblique": FontDescriptor(
+ name="Helvetica-Oblique",
+ family="Helvetica",
+ weight="Medium",
+ ascent=718,
+ descent=-207,
+ cap_height=718,
+ x_height=523,
+ italic_angle=-12,
+ flags=96,
+ bbox=(-170.0, -225.0, 1116.0, 931.0),
+ character_widths={
+ " ": 278,
+ "!": 278,
+ '"': 355,
+ "#": 556,
+ "$": 556,
+ "%": 889,
+ "&": 667,
+ "\u2019": 222,
+ "(": 333,
+ ")": 333,
+ "*": 389,
+ "+": 584,
+ ",": 278,
+ "-": 333,
+ ".": 278,
+ "/": 278,
+ "0": 556,
+ "1": 556,
+ "2": 556,
+ "3": 556,
+ "4": 556,
+ "5": 556,
+ "6": 556,
+ "7": 556,
+ "8": 556,
+ "9": 556,
+ ":": 278,
+ ";": 278,
+ "<": 584,
+ "=": 584,
+ ">": 584,
+ "?": 556,
+ "@": 1015,
+ "A": 667,
+ "B": 667,
+ "C": 722,
+ "D": 722,
+ "E": 667,
+ "F": 611,
+ "G": 778,
+ "H": 722,
+ "I": 278,
+ "J": 500,
+ "K": 667,
+ "L": 556,
+ "M": 833,
+ "N": 722,
+ "O": 778,
+ "P": 667,
+ "Q": 778,
+ "R": 722,
+ "S": 667,
+ "T": 611,
+ "U": 722,
+ "V": 667,
+ "W": 944,
+ "X": 667,
+ "Y": 667,
+ "Z": 611,
+ "[": 278,
+ "\\": 278,
+ "]": 278,
+ "^": 469,
+ "_": 556,
+ "\u2018": 222,
+ "a": 556,
+ "b": 556,
+ "c": 500,
+ "d": 556,
+ "e": 556,
+ "f": 278,
+ "g": 556,
+ "h": 556,
+ "i": 222,
+ "j": 222,
+ "k": 500,
+ "l": 222,
+ "m": 833,
+ "n": 556,
+ "o": 556,
+ "p": 556,
+ "q": 556,
+ "r": 333,
+ "s": 500,
+ "t": 278,
+ "u": 556,
+ "v": 500,
+ "w": 722,
+ "x": 500,
+ "y": 500,
+ "z": 500,
+ "{": 334,
+ "|": 260,
+ "}": 334,
+ "~": 584,
+ "\xa1": 333,
+ "\xa2": 556,
+ "\xa3": 556,
+ "\u2044": 167,
+ "\xa5": 556,
+ "\u0192": 556,
+ "\xa7": 556,
+ "\xa4": 556,
+ "'": 191,
+ "\u201c": 333,
+ "\xab": 556,
+ "\u2039": 333,
+ "\u203a": 333,
+ "\ufb01": 500,
+ "\ufb02": 500,
+ "\u2013": 556,
+ "\u2020": 556,
+ "\u2021": 556,
+ "\xb7": 278,
+ "\xb6": 537,
+ "\u2022": 350,
+ "\u201a": 222,
+ "\u201e": 333,
+ "\u201d": 333,
+ "\xbb": 556,
+ "\u2026": 1000,
+ "\u2030": 1000,
+ "\xbf": 611,
+ "`": 333,
+ "\xb4": 333,
+ "\u02c6": 333,
+ "\u02dc": 333,
+ "\xaf": 333,
+ "\u02d8": 333,
+ "\u02d9": 333,
+ "\xa8": 333,
+ "\u02da": 333,
+ "\xb8": 333,
+ "\u02dd": 333,
+ "\u02db": 333,
+ "\u02c7": 333,
+ "\u2014": 1000,
+ "\xc6": 1000,
+ "\xaa": 370,
+ "\u0141": 556,
+ "\xd8": 778,
+ "\u0152": 1000,
+ "\xba": 365,
+ "\xe6": 889,
+ "\u0131": 278,
+ "\u0142": 222,
+ "\xf8": 611,
+ "\u0153": 944,
+ "\xdf": 611,
+ "\xcf": 278,
+ "\xe9": 556,
+ "\u0103": 556,
+ "\u0171": 556,
+ "\u011b": 556,
+ "\u0178": 667,
+ "\xf7": 584,
+ "\xdd": 667,
+ "\xc2": 667,
+ "\xe1": 556,
+ "\xdb": 722,
+ "\xfd": 500,
+ "\u0219": 500,
+ "\xea": 556,
+ "\u016e": 722,
+ "\xdc": 722,
+ "\u0105": 556,
+ "\xda": 722,
+ "\u0173": 556,
+ "\xcb": 667,
+ "\u0110": 722,
+ "\uf6c3": 250,
+ "\xa9": 737,
+ "\u0112": 667,
+ "\u010d": 500,
+ "\xe5": 556,
+ "\u0145": 722,
+ "\u013a": 222,
+ "\xe0": 556,
+ "\u0162": 611,
+ "\u0106": 722,
+ "\xe3": 556,
+ "\u0116": 667,
+ "\u0161": 500,
+ "\u015f": 500,
+ "\xed": 278,
+ "\u25ca": 471,
+ "\u0158": 722,
+ "\u0122": 778,
+ "\xfb": 556,
+ "\xe2": 556,
+ "\u0100": 667,
+ "\u0159": 333,
+ "\xe7": 500,
+ "\u017b": 611,
+ "\xde": 667,
+ "\u014c": 778,
+ "\u0154": 722,
+ "\u015a": 667,
+ "\u010f": 643,
+ "\u016a": 722,
+ "\u016f": 556,
+ "\xb3": 333,
+ "\xd2": 778,
+ "\xc0": 667,
+ "\u0102": 667,
+ "\xd7": 584,
+ "\xfa": 556,
+ "\u0164": 611,
+ "\u2202": 476,
+ "\xff": 500,
+ "\u0143": 722,
+ "\xee": 278,
+ "\xca": 667,
+ "\xe4": 556,
+ "\xeb": 556,
+ "\u0107": 500,
+ "\u0144": 556,
+ "\u016b": 556,
+ "\u0147": 722,
+ "\xcd": 278,
+ "\xb1": 584,
+ "\xa6": 260,
+ "\xae": 737,
+ "\u011e": 778,
+ "\u0130": 278,
+ "\u2211": 600,
+ "\xc8": 667,
+ "\u0155": 333,
+ "\u014d": 556,
+ "\u0179": 611,
+ "\u017d": 611,
+ "\u2265": 549,
+ "\xd0": 722,
+ "\xc7": 722,
+ "\u013c": 222,
+ "\u0165": 317,
+ "\u0119": 556,
+ "\u0172": 722,
+ "\xc1": 667,
+ "\xc4": 667,
+ "\xe8": 556,
+ "\u017a": 500,
+ "\u012f": 222,
+ "\xd3": 778,
+ "\xf3": 556,
+ "\u0101": 556,
+ "\u015b": 500,
+ "\xef": 278,
+ "\xd4": 778,
+ "\xd9": 722,
+ "\u2206": 612,
+ "\xfe": 556,
+ "\xb2": 333,
+ "\xd6": 778,
+ "\xb5": 556,
+ "\xec": 278,
+ "\u0151": 556,
+ "\u0118": 667,
+ "\u0111": 556,
+ "\xbe": 834,
+ "\u015e": 667,
+ "\u013e": 299,
+ "\u0136": 667,
+ "\u0139": 556,
+ "\u2122": 1000,
+ "\u0117": 556,
+ "\xcc": 278,
+ "\u012a": 278,
+ "\u013d": 556,
+ "\xbd": 834,
+ "\u2264": 549,
+ "\xf4": 556,
+ "\xf1": 556,
+ "\u0170": 722,
+ "\xc9": 667,
+ "\u0113": 556,
+ "\u011f": 556,
+ "\xbc": 834,
+ "\u0160": 667,
+ "\u0218": 667,
+ "\u0150": 778,
+ "\xb0": 400,
+ "\xf2": 556,
+ "\u010c": 722,
+ "\xf9": 556,
+ "\u221a": 453,
+ "\u010e": 722,
+ "\u0157": 333,
+ "\xd1": 722,
+ "\xf5": 556,
+ "\u0156": 722,
+ "\u013b": 556,
+ "\xc3": 667,
+ "\u0104": 667,
+ "\xc5": 667,
+ "\xd5": 778,
+ "\u017c": 500,
+ "\u011a": 667,
+ "\u012e": 278,
+ "\u0137": 500,
+ "\u2212": 584,
+ "\xce": 278,
+ "\u0148": 556,
+ "\u0163": 278,
+ "\xac": 584,
+ "\xf6": 556,
+ "\xfc": 556,
+ "\u2260": 549,
+ "\u0123": 556,
+ "\xf0": 556,
+ "\u017e": 500,
+ "\u0146": 556,
+ "\xb9": 333,
+ "\u012b": 278,
+ "\u20ac": 556,
+ },
+ ),
+ # Generated from Symbol.afm
+ # Copyright (c) 1985, 1987, 1989, 1990, 1997 Adobe Systems Incorporated. All rights reserved.
+ "Symbol": FontDescriptor(
+ name="Symbol",
+ family="Symbol",
+ weight="Medium",
+ ascent=0.0,
+ descent=0.0,
+ cap_height=0.0,
+ x_height=0.0,
+ italic_angle=0,
+ flags=4,
+ bbox=(-180.0, -293.0, 1090.0, 1010.0),
+ character_widths={
+ " ": 250,
+ "!": 333,
+ "\u2200": 713,
+ "#": 500,
+ "\u2203": 549,
+ "%": 833,
+ "&": 778,
+ "\u220b": 439,
+ "(": 333,
+ ")": 333,
+ "\u2217": 500,
+ "+": 549,
+ ",": 250,
+ "\u2212": 549,
+ ".": 250,
+ "/": 278,
+ "0": 500,
+ "1": 500,
+ "2": 500,
+ "3": 500,
+ "4": 500,
+ "5": 500,
+ "6": 500,
+ "7": 500,
+ "8": 500,
+ "9": 500,
+ ":": 278,
+ ";": 278,
+ "<": 549,
+ "=": 549,
+ ">": 549,
+ "?": 444,
+ "\u2245": 549,
+ "\u0391": 722,
+ "\u0392": 667,
+ "\u03a7": 722,
+ "\u2206": 612,
+ "\u0395": 611,
+ "\u03a6": 763,
+ "\u0393": 603,
+ "\u0397": 722,
+ "\u0399": 333,
+ "\u03d1": 631,
+ "\u039a": 722,
+ "\u039b": 686,
+ "\u039c": 889,
+ "\u039d": 722,
+ "\u039f": 722,
+ "\u03a0": 768,
+ "\u0398": 741,
+ "\u03a1": 556,
+ "\u03a3": 592,
+ "\u03a4": 611,
+ "\u03a5": 690,
+ "\u03c2": 439,
+ "\u2126": 768,
+ "\u039e": 645,
+ "\u03a8": 795,
+ "\u0396": 611,
+ "[": 333,
+ "\u2234": 863,
+ "]": 333,
+ "\u22a5": 658,
+ "_": 500,
+ "\uf8e5": 500,
+ "\u03b1": 631,
+ "\u03b2": 549,
+ "\u03c7": 549,
+ "\u03b4": 494,
+ "\u03b5": 439,
+ "\u03c6": 521,
+ "\u03b3": 411,
+ "\u03b7": 603,
+ "\u03b9": 329,
+ "\u03d5": 603,
+ "\u03ba": 549,
+ "\u03bb": 549,
+ "\xb5": 576,
+ "\u03bd": 521,
+ "\u03bf": 549,
+ "\u03c0": 549,
+ "\u03b8": 521,
+ "\u03c1": 549,
+ "\u03c3": 603,
+ "\u03c4": 439,
+ "\u03c5": 576,
+ "\u03d6": 713,
+ "\u03c9": 686,
+ "\u03be": 493,
+ "\u03c8": 686,
+ "\u03b6": 494,
+ "{": 480,
+ "|": 200,
+ "}": 480,
+ "\u223c": 549,
+ "\u20ac": 750,
+ "\u03d2": 620,
+ "\u2032": 247,
+ "\u2264": 549,
+ "\u2044": 167,
+ "\u221e": 713,
+ "\u0192": 500,
+ "\u2663": 753,
+ "\u2666": 753,
+ "\u2665": 753,
+ "\u2660": 753,
+ "\u2194": 1042,
+ "\u2190": 987,
+ "\u2191": 603,
+ "\u2192": 987,
+ "\u2193": 603,
+ "\xb0": 400,
+ "\xb1": 549,
+ "\u2033": 411,
+ "\u2265": 549,
+ "\xd7": 549,
+ "\u221d": 713,
+ "\u2202": 494,
+ "\u2022": 460,
+ "\xf7": 549,
+ "\u2260": 549,
+ "\u2261": 549,
+ "\u2248": 549,
+ "\u2026": 1000,
+ "\uf8e6": 603,
+ "\uf8e7": 1000,
+ "\u21b5": 658,
+ "\u2135": 823,
+ "\u2111": 686,
+ "\u211c": 795,
+ "\u2118": 987,
+ "\u2297": 768,
+ "\u2295": 768,
+ "\u2205": 823,
+ "\u2229": 768,
+ "\u222a": 768,
+ "\u2283": 713,
+ "\u2287": 713,
+ "\u2284": 713,
+ "\u2282": 713,
+ "\u2286": 713,
+ "\u2208": 713,
+ "\u2209": 713,
+ "\u2220": 768,
+ "\u2207": 713,
+ "\uf6da": 790,
+ "\uf6d9": 790,
+ "\uf6db": 890,
+ "\u220f": 823,
+ "\u221a": 549,
+ "\u22c5": 250,
+ "\xac": 713,
+ "\u2227": 603,
+ "\u2228": 603,
+ "\u21d4": 1042,
+ "\u21d0": 987,
+ "\u21d1": 603,
+ "\u21d2": 987,
+ "\u21d3": 603,
+ "\u25ca": 494,
+ "\u2329": 329,
+ "\uf8e8": 790,
+ "\uf8e9": 790,
+ "\uf8ea": 786,
+ "\u2211": 713,
+ "\uf8eb": 384,
+ "\uf8ec": 384,
+ "\uf8ed": 384,
+ "\uf8ee": 384,
+ "\uf8ef": 384,
+ "\uf8f0": 384,
+ "\uf8f1": 494,
+ "\uf8f2": 494,
+ "\uf8f3": 494,
+ "\uf8f4": 494,
+ "\u232a": 329,
+ "\u222b": 274,
+ "\u2320": 686,
+ "\uf8f5": 686,
+ "\u2321": 686,
+ "\uf8f6": 384,
+ "\uf8f7": 384,
+ "\uf8f8": 384,
+ "\uf8f9": 384,
+ "\uf8fa": 384,
+ "\uf8fb": 384,
+ "\uf8fc": 494,
+ "\uf8fd": 494,
+ "\uf8fe": 494,
+ "\uf8ff": 790,
+ },
+ ),
+ # Generated from Times-Bold.afm
+ # Copyright (c) 1985, 1987, 1989, 1990, 1993, 1997 Adobe Systems Incorporated. All Rights
+ # Reserved. Times is a trademark of Linotype-Hell AG and/or its subsidiaries.
+ "Times-Bold": FontDescriptor(
+ name="Times-Bold",
+ family="Times",
+ weight="Bold",
+ ascent=683,
+ descent=-217,
+ cap_height=676,
+ x_height=461,
+ italic_angle=0,
+ flags=34,
+ bbox=(-168.0, -218.0, 1000.0, 935.0),
+ character_widths={
+ " ": 250,
+ "!": 333,
+ '"': 555,
+ "#": 500,
+ "$": 500,
+ "%": 1000,
+ "&": 833,
+ "\u2019": 333,
+ "(": 333,
+ ")": 333,
+ "*": 500,
+ "+": 570,
+ ",": 250,
+ "-": 333,
+ ".": 250,
+ "/": 278,
+ "0": 500,
+ "1": 500,
+ "2": 500,
+ "3": 500,
+ "4": 500,
+ "5": 500,
+ "6": 500,
+ "7": 500,
+ "8": 500,
+ "9": 500,
+ ":": 333,
+ ";": 333,
+ "<": 570,
+ "=": 570,
+ ">": 570,
+ "?": 500,
+ "@": 930,
+ "A": 722,
+ "B": 667,
+ "C": 722,
+ "D": 722,
+ "E": 667,
+ "F": 611,
+ "G": 778,
+ "H": 778,
+ "I": 389,
+ "J": 500,
+ "K": 778,
+ "L": 667,
+ "M": 944,
+ "N": 722,
+ "O": 778,
+ "P": 611,
+ "Q": 778,
+ "R": 722,
+ "S": 556,
+ "T": 667,
+ "U": 722,
+ "V": 722,
+ "W": 1000,
+ "X": 722,
+ "Y": 722,
+ "Z": 667,
+ "[": 333,
+ "\\": 278,
+ "]": 333,
+ "^": 581,
+ "_": 500,
+ "\u2018": 333,
+ "a": 500,
+ "b": 556,
+ "c": 444,
+ "d": 556,
+ "e": 444,
+ "f": 333,
+ "g": 500,
+ "h": 556,
+ "i": 278,
+ "j": 333,
+ "k": 556,
+ "l": 278,
+ "m": 833,
+ "n": 556,
+ "o": 500,
+ "p": 556,
+ "q": 556,
+ "r": 444,
+ "s": 389,
+ "t": 333,
+ "u": 556,
+ "v": 500,
+ "w": 722,
+ "x": 500,
+ "y": 500,
+ "z": 444,
+ "{": 394,
+ "|": 220,
+ "}": 394,
+ "~": 520,
+ "\xa1": 333,
+ "\xa2": 500,
+ "\xa3": 500,
+ "\u2044": 167,
+ "\xa5": 500,
+ "\u0192": 500,
+ "\xa7": 500,
+ "\xa4": 500,
+ "'": 278,
+ "\u201c": 500,
+ "\xab": 500,
+ "\u2039": 333,
+ "\u203a": 333,
+ "\ufb01": 556,
+ "\ufb02": 556,
+ "\u2013": 500,
+ "\u2020": 500,
+ "\u2021": 500,
+ "\xb7": 250,
+ "\xb6": 540,
+ "\u2022": 350,
+ "\u201a": 333,
+ "\u201e": 500,
+ "\u201d": 500,
+ "\xbb": 500,
+ "\u2026": 1000,
+ "\u2030": 1000,
+ "\xbf": 500,
+ "`": 333,
+ "\xb4": 333,
+ "\u02c6": 333,
+ "\u02dc": 333,
+ "\xaf": 333,
+ "\u02d8": 333,
+ "\u02d9": 333,
+ "\xa8": 333,
+ "\u02da": 333,
+ "\xb8": 333,
+ "\u02dd": 333,
+ "\u02db": 333,
+ "\u02c7": 333,
+ "\u2014": 1000,
+ "\xc6": 1000,
+ "\xaa": 300,
+ "\u0141": 667,
+ "\xd8": 778,
+ "\u0152": 1000,
+ "\xba": 330,
+ "\xe6": 722,
+ "\u0131": 278,
+ "\u0142": 278,
+ "\xf8": 500,
+ "\u0153": 722,
+ "\xdf": 556,
+ "\xcf": 389,
+ "\xe9": 444,
+ "\u0103": 500,
+ "\u0171": 556,
+ "\u011b": 444,
+ "\u0178": 722,
+ "\xf7": 570,
+ "\xdd": 722,
+ "\xc2": 722,
+ "\xe1": 500,
+ "\xdb": 722,
+ "\xfd": 500,
+ "\u0219": 389,
+ "\xea": 444,
+ "\u016e": 722,
+ "\xdc": 722,
+ "\u0105": 500,
+ "\xda": 722,
+ "\u0173": 556,
+ "\xcb": 667,
+ "\u0110": 722,
+ "\uf6c3": 250,
+ "\xa9": 747,
+ "\u0112": 667,
+ "\u010d": 444,
+ "\xe5": 500,
+ "\u0145": 722,
+ "\u013a": 278,
+ "\xe0": 500,
+ "\u0162": 667,
+ "\u0106": 722,
+ "\xe3": 500,
+ "\u0116": 667,
+ "\u0161": 389,
+ "\u015f": 389,
+ "\xed": 278,
+ "\u25ca": 494,
+ "\u0158": 722,
+ "\u0122": 778,
+ "\xfb": 556,
+ "\xe2": 500,
+ "\u0100": 722,
+ "\u0159": 444,
+ "\xe7": 444,
+ "\u017b": 667,
+ "\xde": 611,
+ "\u014c": 778,
+ "\u0154": 722,
+ "\u015a": 556,
+ "\u010f": 672,
+ "\u016a": 722,
+ "\u016f": 556,
+ "\xb3": 300,
+ "\xd2": 778,
+ "\xc0": 722,
+ "\u0102": 722,
+ "\xd7": 570,
+ "\xfa": 556,
+ "\u0164": 667,
+ "\u2202": 494,
+ "\xff": 500,
+ "\u0143": 722,
+ "\xee": 278,
+ "\xca": 667,
+ "\xe4": 500,
+ "\xeb": 444,
+ "\u0107": 444,
+ "\u0144": 556,
+ "\u016b": 556,
+ "\u0147": 722,
+ "\xcd": 389,
+ "\xb1": 570,
+ "\xa6": 220,
+ "\xae": 747,
+ "\u011e": 778,
+ "\u0130": 389,
+ "\u2211": 600,
+ "\xc8": 667,
+ "\u0155": 444,
+ "\u014d": 500,
+ "\u0179": 667,
+ "\u017d": 667,
+ "\u2265": 549,
+ "\xd0": 722,
+ "\xc7": 722,
+ "\u013c": 278,
+ "\u0165": 416,
+ "\u0119": 444,
+ "\u0172": 722,
+ "\xc1": 722,
+ "\xc4": 722,
+ "\xe8": 444,
+ "\u017a": 444,
+ "\u012f": 278,
+ "\xd3": 778,
+ "\xf3": 500,
+ "\u0101": 500,
+ "\u015b": 389,
+ "\xef": 278,
+ "\xd4": 778,
+ "\xd9": 722,
+ "\u2206": 612,
+ "\xfe": 556,
+ "\xb2": 300,
+ "\xd6": 778,
+ "\xb5": 556,
+ "\xec": 278,
+ "\u0151": 500,
+ "\u0118": 667,
+ "\u0111": 556,
+ "\xbe": 750,
+ "\u015e": 556,
+ "\u013e": 394,
+ "\u0136": 778,
+ "\u0139": 667,
+ "\u2122": 1000,
+ "\u0117": 444,
+ "\xcc": 389,
+ "\u012a": 389,
+ "\u013d": 667,
+ "\xbd": 750,
+ "\u2264": 549,
+ "\xf4": 500,
+ "\xf1": 556,
+ "\u0170": 722,
+ "\xc9": 667,
+ "\u0113": 444,
+ "\u011f": 500,
+ "\xbc": 750,
+ "\u0160": 556,
+ "\u0218": 556,
+ "\u0150": 778,
+ "\xb0": 400,
+ "\xf2": 500,
+ "\u010c": 722,
+ "\xf9": 556,
+ "\u221a": 549,
+ "\u010e": 722,
+ "\u0157": 444,
+ "\xd1": 722,
+ "\xf5": 500,
+ "\u0156": 722,
+ "\u013b": 667,
+ "\xc3": 722,
+ "\u0104": 722,
+ "\xc5": 722,
+ "\xd5": 778,
+ "\u017c": 444,
+ "\u011a": 667,
+ "\u012e": 389,
+ "\u0137": 556,
+ "\u2212": 570,
+ "\xce": 389,
+ "\u0148": 556,
+ "\u0163": 333,
+ "\xac": 570,
+ "\xf6": 500,
+ "\xfc": 556,
+ "\u2260": 549,
+ "\u0123": 500,
+ "\xf0": 500,
+ "\u017e": 444,
+ "\u0146": 556,
+ "\xb9": 300,
+ "\u012b": 278,
+ "\u20ac": 500,
+ },
+ ),
+ # Generated from Times-BoldItalic.afm
+ # Copyright (c) 1985, 1987, 1989, 1990, 1993, 1997 Adobe Systems Incorporated. All Rights
+ # Reserved. Times is a trademark of Linotype-Hell AG and/or its subsidiaries.
+ "Times-BoldItalic": FontDescriptor(
+ name="Times-BoldItalic",
+ family="Times",
+ weight="Bold",
+ ascent=683,
+ descent=-217,
+ cap_height=669,
+ x_height=462,
+ italic_angle=-15,
+ flags=98,
+ bbox=(-200.0, -218.0, 996.0, 921.0),
+ character_widths={
+ " ": 250,
+ "!": 389,
+ '"': 555,
+ "#": 500,
+ "$": 500,
+ "%": 833,
+ "&": 778,
+ "\u2019": 333,
+ "(": 333,
+ ")": 333,
+ "*": 500,
+ "+": 570,
+ ",": 250,
+ "-": 333,
+ ".": 250,
+ "/": 278,
+ "0": 500,
+ "1": 500,
+ "2": 500,
+ "3": 500,
+ "4": 500,
+ "5": 500,
+ "6": 500,
+ "7": 500,
+ "8": 500,
+ "9": 500,
+ ":": 333,
+ ";": 333,
+ "<": 570,
+ "=": 570,
+ ">": 570,
+ "?": 500,
+ "@": 832,
+ "A": 667,
+ "B": 667,
+ "C": 667,
+ "D": 722,
+ "E": 667,
+ "F": 667,
+ "G": 722,
+ "H": 778,
+ "I": 389,
+ "J": 500,
+ "K": 667,
+ "L": 611,
+ "M": 889,
+ "N": 722,
+ "O": 722,
+ "P": 611,
+ "Q": 722,
+ "R": 667,
+ "S": 556,
+ "T": 611,
+ "U": 722,
+ "V": 667,
+ "W": 889,
+ "X": 667,
+ "Y": 611,
+ "Z": 611,
+ "[": 333,
+ "\\": 278,
+ "]": 333,
+ "^": 570,
+ "_": 500,
+ "\u2018": 333,
+ "a": 500,
+ "b": 500,
+ "c": 444,
+ "d": 500,
+ "e": 444,
+ "f": 333,
+ "g": 500,
+ "h": 556,
+ "i": 278,
+ "j": 278,
+ "k": 500,
+ "l": 278,
+ "m": 778,
+ "n": 556,
+ "o": 500,
+ "p": 500,
+ "q": 500,
+ "r": 389,
+ "s": 389,
+ "t": 278,
+ "u": 556,
+ "v": 444,
+ "w": 667,
+ "x": 500,
+ "y": 444,
+ "z": 389,
+ "{": 348,
+ "|": 220,
+ "}": 348,
+ "~": 570,
+ "\xa1": 389,
+ "\xa2": 500,
+ "\xa3": 500,
+ "\u2044": 167,
+ "\xa5": 500,
+ "\u0192": 500,
+ "\xa7": 500,
+ "\xa4": 500,
+ "'": 278,
+ "\u201c": 500,
+ "\xab": 500,
+ "\u2039": 333,
+ "\u203a": 333,
+ "\ufb01": 556,
+ "\ufb02": 556,
+ "\u2013": 500,
+ "\u2020": 500,
+ "\u2021": 500,
+ "\xb7": 250,
+ "\xb6": 500,
+ "\u2022": 350,
+ "\u201a": 333,
+ "\u201e": 500,
+ "\u201d": 500,
+ "\xbb": 500,
+ "\u2026": 1000,
+ "\u2030": 1000,
+ "\xbf": 500,
+ "`": 333,
+ "\xb4": 333,
+ "\u02c6": 333,
+ "\u02dc": 333,
+ "\xaf": 333,
+ "\u02d8": 333,
+ "\u02d9": 333,
+ "\xa8": 333,
+ "\u02da": 333,
+ "\xb8": 333,
+ "\u02dd": 333,
+ "\u02db": 333,
+ "\u02c7": 333,
+ "\u2014": 1000,
+ "\xc6": 944,
+ "\xaa": 266,
+ "\u0141": 611,
+ "\xd8": 722,
+ "\u0152": 944,
+ "\xba": 300,
+ "\xe6": 722,
+ "\u0131": 278,
+ "\u0142": 278,
+ "\xf8": 500,
+ "\u0153": 722,
+ "\xdf": 500,
+ "\xcf": 389,
+ "\xe9": 444,
+ "\u0103": 500,
+ "\u0171": 556,
+ "\u011b": 444,
+ "\u0178": 611,
+ "\xf7": 570,
+ "\xdd": 611,
+ "\xc2": 667,
+ "\xe1": 500,
+ "\xdb": 722,
+ "\xfd": 444,
+ "\u0219": 389,
+ "\xea": 444,
+ "\u016e": 722,
+ "\xdc": 722,
+ "\u0105": 500,
+ "\xda": 722,
+ "\u0173": 556,
+ "\xcb": 667,
+ "\u0110": 722,
+ "\uf6c3": 250,
+ "\xa9": 747,
+ "\u0112": 667,
+ "\u010d": 444,
+ "\xe5": 500,
+ "\u0145": 722,
+ "\u013a": 278,
+ "\xe0": 500,
+ "\u0162": 611,
+ "\u0106": 667,
+ "\xe3": 500,
+ "\u0116": 667,
+ "\u0161": 389,
+ "\u015f": 389,
+ "\xed": 278,
+ "\u25ca": 494,
+ "\u0158": 667,
+ "\u0122": 722,
+ "\xfb": 556,
+ "\xe2": 500,
+ "\u0100": 667,
+ "\u0159": 389,
+ "\xe7": 444,
+ "\u017b": 611,
+ "\xde": 611,
+ "\u014c": 722,
+ "\u0154": 667,
+ "\u015a": 556,
+ "\u010f": 608,
+ "\u016a": 722,
+ "\u016f": 556,
+ "\xb3": 300,
+ "\xd2": 722,
+ "\xc0": 667,
+ "\u0102": 667,
+ "\xd7": 570,
+ "\xfa": 556,
+ "\u0164": 611,
+ "\u2202": 494,
+ "\xff": 444,
+ "\u0143": 722,
+ "\xee": 278,
+ "\xca": 667,
+ "\xe4": 500,
+ "\xeb": 444,
+ "\u0107": 444,
+ "\u0144": 556,
+ "\u016b": 556,
+ "\u0147": 722,
+ "\xcd": 389,
+ "\xb1": 570,
+ "\xa6": 220,
+ "\xae": 747,
+ "\u011e": 722,
+ "\u0130": 389,
+ "\u2211": 600,
+ "\xc8": 667,
+ "\u0155": 389,
+ "\u014d": 500,
+ "\u0179": 611,
+ "\u017d": 611,
+ "\u2265": 549,
+ "\xd0": 722,
+ "\xc7": 667,
+ "\u013c": 278,
+ "\u0165": 366,
+ "\u0119": 444,
+ "\u0172": 722,
+ "\xc1": 667,
+ "\xc4": 667,
+ "\xe8": 444,
+ "\u017a": 389,
+ "\u012f": 278,
+ "\xd3": 722,
+ "\xf3": 500,
+ "\u0101": 500,
+ "\u015b": 389,
+ "\xef": 278,
+ "\xd4": 722,
+ "\xd9": 722,
+ "\u2206": 612,
+ "\xfe": 500,
+ "\xb2": 300,
+ "\xd6": 722,
+ "\xb5": 576,
+ "\xec": 278,
+ "\u0151": 500,
+ "\u0118": 667,
+ "\u0111": 500,
+ "\xbe": 750,
+ "\u015e": 556,
+ "\u013e": 382,
+ "\u0136": 667,
+ "\u0139": 611,
+ "\u2122": 1000,
+ "\u0117": 444,
+ "\xcc": 389,
+ "\u012a": 389,
+ "\u013d": 611,
+ "\xbd": 750,
+ "\u2264": 549,
+ "\xf4": 500,
+ "\xf1": 556,
+ "\u0170": 722,
+ "\xc9": 667,
+ "\u0113": 444,
+ "\u011f": 500,
+ "\xbc": 750,
+ "\u0160": 556,
+ "\u0218": 556,
+ "\u0150": 722,
+ "\xb0": 400,
+ "\xf2": 500,
+ "\u010c": 667,
+ "\xf9": 556,
+ "\u221a": 549,
+ "\u010e": 722,
+ "\u0157": 389,
+ "\xd1": 722,
+ "\xf5": 500,
+ "\u0156": 667,
+ "\u013b": 611,
+ "\xc3": 667,
+ "\u0104": 667,
+ "\xc5": 667,
+ "\xd5": 722,
+ "\u017c": 389,
+ "\u011a": 667,
+ "\u012e": 389,
+ "\u0137": 500,
+ "\u2212": 606,
+ "\xce": 389,
+ "\u0148": 556,
+ "\u0163": 278,
+ "\xac": 606,
+ "\xf6": 500,
+ "\xfc": 556,
+ "\u2260": 549,
+ "\u0123": 500,
+ "\xf0": 500,
+ "\u017e": 389,
+ "\u0146": 556,
+ "\xb9": 300,
+ "\u012b": 278,
+ "\u20ac": 500,
+ },
+ ),
+ # Generated from Times-Italic.afm
+ # Copyright (c) 1985, 1987, 1989, 1990, 1993, 1997 Adobe Systems Incorporated. All Rights
+ # Reserved. Times is a trademark of Linotype-Hell AG and/or its subsidiaries.
+ "Times-Italic": FontDescriptor(
+ name="Times-Italic",
+ family="Times",
+ weight="Medium",
+ ascent=683,
+ descent=-217,
+ cap_height=653,
+ x_height=441,
+ italic_angle=-15.5,
+ flags=98,
+ bbox=(-169.0, -217.0, 1010.0, 883.0),
+ character_widths={
+ " ": 250,
+ "!": 333,
+ '"': 420,
+ "#": 500,
+ "$": 500,
+ "%": 833,
+ "&": 778,
+ "\u2019": 333,
+ "(": 333,
+ ")": 333,
+ "*": 500,
+ "+": 675,
+ ",": 250,
+ "-": 333,
+ ".": 250,
+ "/": 278,
+ "0": 500,
+ "1": 500,
+ "2": 500,
+ "3": 500,
+ "4": 500,
+ "5": 500,
+ "6": 500,
+ "7": 500,
+ "8": 500,
+ "9": 500,
+ ":": 333,
+ ";": 333,
+ "<": 675,
+ "=": 675,
+ ">": 675,
+ "?": 500,
+ "@": 920,
+ "A": 611,
+ "B": 611,
+ "C": 667,
+ "D": 722,
+ "E": 611,
+ "F": 611,
+ "G": 722,
+ "H": 722,
+ "I": 333,
+ "J": 444,
+ "K": 667,
+ "L": 556,
+ "M": 833,
+ "N": 667,
+ "O": 722,
+ "P": 611,
+ "Q": 722,
+ "R": 611,
+ "S": 500,
+ "T": 556,
+ "U": 722,
+ "V": 611,
+ "W": 833,
+ "X": 611,
+ "Y": 556,
+ "Z": 556,
+ "[": 389,
+ "\\": 278,
+ "]": 389,
+ "^": 422,
+ "_": 500,
+ "\u2018": 333,
+ "a": 500,
+ "b": 500,
+ "c": 444,
+ "d": 500,
+ "e": 444,
+ "f": 278,
+ "g": 500,
+ "h": 500,
+ "i": 278,
+ "j": 278,
+ "k": 444,
+ "l": 278,
+ "m": 722,
+ "n": 500,
+ "o": 500,
+ "p": 500,
+ "q": 500,
+ "r": 389,
+ "s": 389,
+ "t": 278,
+ "u": 500,
+ "v": 444,
+ "w": 667,
+ "x": 444,
+ "y": 444,
+ "z": 389,
+ "{": 400,
+ "|": 275,
+ "}": 400,
+ "~": 541,
+ "\xa1": 389,
+ "\xa2": 500,
+ "\xa3": 500,
+ "\u2044": 167,
+ "\xa5": 500,
+ "\u0192": 500,
+ "\xa7": 500,
+ "\xa4": 500,
+ "'": 214,
+ "\u201c": 556,
+ "\xab": 500,
+ "\u2039": 333,
+ "\u203a": 333,
+ "\ufb01": 500,
+ "\ufb02": 500,
+ "\u2013": 500,
+ "\u2020": 500,
+ "\u2021": 500,
+ "\xb7": 250,
+ "\xb6": 523,
+ "\u2022": 350,
+ "\u201a": 333,
+ "\u201e": 556,
+ "\u201d": 556,
+ "\xbb": 500,
+ "\u2026": 889,
+ "\u2030": 1000,
+ "\xbf": 500,
+ "`": 333,
+ "\xb4": 333,
+ "\u02c6": 333,
+ "\u02dc": 333,
+ "\xaf": 333,
+ "\u02d8": 333,
+ "\u02d9": 333,
+ "\xa8": 333,
+ "\u02da": 333,
+ "\xb8": 333,
+ "\u02dd": 333,
+ "\u02db": 333,
+ "\u02c7": 333,
+ "\u2014": 889,
+ "\xc6": 889,
+ "\xaa": 276,
+ "\u0141": 556,
+ "\xd8": 722,
+ "\u0152": 944,
+ "\xba": 310,
+ "\xe6": 667,
+ "\u0131": 278,
+ "\u0142": 278,
+ "\xf8": 500,
+ "\u0153": 667,
+ "\xdf": 500,
+ "\xcf": 333,
+ "\xe9": 444,
+ "\u0103": 500,
+ "\u0171": 500,
+ "\u011b": 444,
+ "\u0178": 556,
+ "\xf7": 675,
+ "\xdd": 556,
+ "\xc2": 611,
+ "\xe1": 500,
+ "\xdb": 722,
+ "\xfd": 444,
+ "\u0219": 389,
+ "\xea": 444,
+ "\u016e": 722,
+ "\xdc": 722,
+ "\u0105": 500,
+ "\xda": 722,
+ "\u0173": 500,
+ "\xcb": 611,
+ "\u0110": 722,
+ "\uf6c3": 250,
+ "\xa9": 760,
+ "\u0112": 611,
+ "\u010d": 444,
+ "\xe5": 500,
+ "\u0145": 667,
+ "\u013a": 278,
+ "\xe0": 500,
+ "\u0162": 556,
+ "\u0106": 667,
+ "\xe3": 500,
+ "\u0116": 611,
+ "\u0161": 389,
+ "\u015f": 389,
+ "\xed": 278,
+ "\u25ca": 471,
+ "\u0158": 611,
+ "\u0122": 722,
+ "\xfb": 500,
+ "\xe2": 500,
+ "\u0100": 611,
+ "\u0159": 389,
+ "\xe7": 444,
+ "\u017b": 556,
+ "\xde": 611,
+ "\u014c": 722,
+ "\u0154": 611,
+ "\u015a": 500,
+ "\u010f": 544,
+ "\u016a": 722,
+ "\u016f": 500,
+ "\xb3": 300,
+ "\xd2": 722,
+ "\xc0": 611,
+ "\u0102": 611,
+ "\xd7": 675,
+ "\xfa": 500,
+ "\u0164": 556,
+ "\u2202": 476,
+ "\xff": 444,
+ "\u0143": 667,
+ "\xee": 278,
+ "\xca": 611,
+ "\xe4": 500,
+ "\xeb": 444,
+ "\u0107": 444,
+ "\u0144": 500,
+ "\u016b": 500,
+ "\u0147": 667,
+ "\xcd": 333,
+ "\xb1": 675,
+ "\xa6": 275,
+ "\xae": 760,
+ "\u011e": 722,
+ "\u0130": 333,
+ "\u2211": 600,
+ "\xc8": 611,
+ "\u0155": 389,
+ "\u014d": 500,
+ "\u0179": 556,
+ "\u017d": 556,
+ "\u2265": 549,
+ "\xd0": 722,
+ "\xc7": 667,
+ "\u013c": 278,
+ "\u0165": 300,
+ "\u0119": 444,
+ "\u0172": 722,
+ "\xc1": 611,
+ "\xc4": 611,
+ "\xe8": 444,
+ "\u017a": 389,
+ "\u012f": 278,
+ "\xd3": 722,
+ "\xf3": 500,
+ "\u0101": 500,
+ "\u015b": 389,
+ "\xef": 278,
+ "\xd4": 722,
+ "\xd9": 722,
+ "\u2206": 612,
+ "\xfe": 500,
+ "\xb2": 300,
+ "\xd6": 722,
+ "\xb5": 500,
+ "\xec": 278,
+ "\u0151": 500,
+ "\u0118": 611,
+ "\u0111": 500,
+ "\xbe": 750,
+ "\u015e": 500,
+ "\u013e": 300,
+ "\u0136": 667,
+ "\u0139": 556,
+ "\u2122": 980,
+ "\u0117": 444,
+ "\xcc": 333,
+ "\u012a": 333,
+ "\u013d": 611,
+ "\xbd": 750,
+ "\u2264": 549,
+ "\xf4": 500,
+ "\xf1": 500,
+ "\u0170": 722,
+ "\xc9": 611,
+ "\u0113": 444,
+ "\u011f": 500,
+ "\xbc": 750,
+ "\u0160": 500,
+ "\u0218": 500,
+ "\u0150": 722,
+ "\xb0": 400,
+ "\xf2": 500,
+ "\u010c": 667,
+ "\xf9": 500,
+ "\u221a": 453,
+ "\u010e": 722,
+ "\u0157": 389,
+ "\xd1": 667,
+ "\xf5": 500,
+ "\u0156": 611,
+ "\u013b": 556,
+ "\xc3": 611,
+ "\u0104": 611,
+ "\xc5": 611,
+ "\xd5": 722,
+ "\u017c": 389,
+ "\u011a": 611,
+ "\u012e": 333,
+ "\u0137": 444,
+ "\u2212": 675,
+ "\xce": 333,
+ "\u0148": 500,
+ "\u0163": 278,
+ "\xac": 675,
+ "\xf6": 500,
+ "\xfc": 500,
+ "\u2260": 549,
+ "\u0123": 500,
+ "\xf0": 500,
+ "\u017e": 389,
+ "\u0146": 500,
+ "\xb9": 300,
+ "\u012b": 278,
+ "\u20ac": 500,
+ },
+ ),
+ # Generated from Times-Roman.afm
+ # Copyright (c) 1985, 1987, 1989, 1990, 1993, 1997 Adobe Systems Incorporated. All Rights
+ # Reserved. Times is a trademark of Linotype-Hell AG and/or its subsidiaries.
+ "Times-Roman": FontDescriptor(
+ name="Times-Roman",
+ family="Times",
+ weight="Roman",
+ ascent=683,
+ descent=-217,
+ cap_height=662,
+ x_height=450,
+ italic_angle=0,
+ flags=34,
+ bbox=(-168.0, -218.0, 1000.0, 898.0),
+ character_widths={
+ " ": 250,
+ "!": 333,
+ '"': 408,
+ "#": 500,
+ "$": 500,
+ "%": 833,
+ "&": 778,
+ "\u2019": 333,
+ "(": 333,
+ ")": 333,
+ "*": 500,
+ "+": 564,
+ ",": 250,
+ "-": 333,
+ ".": 250,
+ "/": 278,
+ "0": 500,
+ "1": 500,
+ "2": 500,
+ "3": 500,
+ "4": 500,
+ "5": 500,
+ "6": 500,
+ "7": 500,
+ "8": 500,
+ "9": 500,
+ ":": 278,
+ ";": 278,
+ "<": 564,
+ "=": 564,
+ ">": 564,
+ "?": 444,
+ "@": 921,
+ "A": 722,
+ "B": 667,
+ "C": 667,
+ "D": 722,
+ "E": 611,
+ "F": 556,
+ "G": 722,
+ "H": 722,
+ "I": 333,
+ "J": 389,
+ "K": 722,
+ "L": 611,
+ "M": 889,
+ "N": 722,
+ "O": 722,
+ "P": 556,
+ "Q": 722,
+ "R": 667,
+ "S": 556,
+ "T": 611,
+ "U": 722,
+ "V": 722,
+ "W": 944,
+ "X": 722,
+ "Y": 722,
+ "Z": 611,
+ "[": 333,
+ "\\": 278,
+ "]": 333,
+ "^": 469,
+ "_": 500,
+ "\u2018": 333,
+ "a": 444,
+ "b": 500,
+ "c": 444,
+ "d": 500,
+ "e": 444,
+ "f": 333,
+ "g": 500,
+ "h": 500,
+ "i": 278,
+ "j": 278,
+ "k": 500,
+ "l": 278,
+ "m": 778,
+ "n": 500,
+ "o": 500,
+ "p": 500,
+ "q": 500,
+ "r": 333,
+ "s": 389,
+ "t": 278,
+ "u": 500,
+ "v": 500,
+ "w": 722,
+ "x": 500,
+ "y": 500,
+ "z": 444,
+ "{": 480,
+ "|": 200,
+ "}": 480,
+ "~": 541,
+ "\xa1": 333,
+ "\xa2": 500,
+ "\xa3": 500,
+ "\u2044": 167,
+ "\xa5": 500,
+ "\u0192": 500,
+ "\xa7": 500,
+ "\xa4": 500,
+ "'": 180,
+ "\u201c": 444,
+ "\xab": 500,
+ "\u2039": 333,
+ "\u203a": 333,
+ "\ufb01": 556,
+ "\ufb02": 556,
+ "\u2013": 500,
+ "\u2020": 500,
+ "\u2021": 500,
+ "\xb7": 250,
+ "\xb6": 453,
+ "\u2022": 350,
+ "\u201a": 333,
+ "\u201e": 444,
+ "\u201d": 444,
+ "\xbb": 500,
+ "\u2026": 1000,
+ "\u2030": 1000,
+ "\xbf": 444,
+ "`": 333,
+ "\xb4": 333,
+ "\u02c6": 333,
+ "\u02dc": 333,
+ "\xaf": 333,
+ "\u02d8": 333,
+ "\u02d9": 333,
+ "\xa8": 333,
+ "\u02da": 333,
+ "\xb8": 333,
+ "\u02dd": 333,
+ "\u02db": 333,
+ "\u02c7": 333,
+ "\u2014": 1000,
+ "\xc6": 889,
+ "\xaa": 276,
+ "\u0141": 611,
+ "\xd8": 722,
+ "\u0152": 889,
+ "\xba": 310,
+ "\xe6": 667,
+ "\u0131": 278,
+ "\u0142": 278,
+ "\xf8": 500,
+ "\u0153": 722,
+ "\xdf": 500,
+ "\xcf": 333,
+ "\xe9": 444,
+ "\u0103": 444,
+ "\u0171": 500,
+ "\u011b": 444,
+ "\u0178": 722,
+ "\xf7": 564,
+ "\xdd": 722,
+ "\xc2": 722,
+ "\xe1": 444,
+ "\xdb": 722,
+ "\xfd": 500,
+ "\u0219": 389,
+ "\xea": 444,
+ "\u016e": 722,
+ "\xdc": 722,
+ "\u0105": 444,
+ "\xda": 722,
+ "\u0173": 500,
+ "\xcb": 611,
+ "\u0110": 722,
+ "\uf6c3": 250,
+ "\xa9": 760,
+ "\u0112": 611,
+ "\u010d": 444,
+ "\xe5": 444,
+ "\u0145": 722,
+ "\u013a": 278,
+ "\xe0": 444,
+ "\u0162": 611,
+ "\u0106": 667,
+ "\xe3": 444,
+ "\u0116": 611,
+ "\u0161": 389,
+ "\u015f": 389,
+ "\xed": 278,
+ "\u25ca": 471,
+ "\u0158": 667,
+ "\u0122": 722,
+ "\xfb": 500,
+ "\xe2": 444,
+ "\u0100": 722,
+ "\u0159": 333,
+ "\xe7": 444,
+ "\u017b": 611,
+ "\xde": 556,
+ "\u014c": 722,
+ "\u0154": 667,
+ "\u015a": 556,
+ "\u010f": 588,
+ "\u016a": 722,
+ "\u016f": 500,
+ "\xb3": 300,
+ "\xd2": 722,
+ "\xc0": 722,
+ "\u0102": 722,
+ "\xd7": 564,
+ "\xfa": 500,
+ "\u0164": 611,
+ "\u2202": 476,
+ "\xff": 500,
+ "\u0143": 722,
+ "\xee": 278,
+ "\xca": 611,
+ "\xe4": 444,
+ "\xeb": 444,
+ "\u0107": 444,
+ "\u0144": 500,
+ "\u016b": 500,
+ "\u0147": 722,
+ "\xcd": 333,
+ "\xb1": 564,
+ "\xa6": 200,
+ "\xae": 760,
+ "\u011e": 722,
+ "\u0130": 333,
+ "\u2211": 600,
+ "\xc8": 611,
+ "\u0155": 333,
+ "\u014d": 500,
+ "\u0179": 611,
+ "\u017d": 611,
+ "\u2265": 549,
+ "\xd0": 722,
+ "\xc7": 667,
+ "\u013c": 278,
+ "\u0165": 326,
+ "\u0119": 444,
+ "\u0172": 722,
+ "\xc1": 722,
+ "\xc4": 722,
+ "\xe8": 444,
+ "\u017a": 444,
+ "\u012f": 278,
+ "\xd3": 722,
+ "\xf3": 500,
+ "\u0101": 444,
+ "\u015b": 389,
+ "\xef": 278,
+ "\xd4": 722,
+ "\xd9": 722,
+ "\u2206": 612,
+ "\xfe": 500,
+ "\xb2": 300,
+ "\xd6": 722,
+ "\xb5": 500,
+ "\xec": 278,
+ "\u0151": 500,
+ "\u0118": 611,
+ "\u0111": 500,
+ "\xbe": 750,
+ "\u015e": 556,
+ "\u013e": 344,
+ "\u0136": 722,
+ "\u0139": 611,
+ "\u2122": 980,
+ "\u0117": 444,
+ "\xcc": 333,
+ "\u012a": 333,
+ "\u013d": 611,
+ "\xbd": 750,
+ "\u2264": 549,
+ "\xf4": 500,
+ "\xf1": 500,
+ "\u0170": 722,
+ "\xc9": 611,
+ "\u0113": 444,
+ "\u011f": 500,
+ "\xbc": 750,
+ "\u0160": 556,
+ "\u0218": 556,
+ "\u0150": 722,
+ "\xb0": 400,
+ "\xf2": 500,
+ "\u010c": 667,
+ "\xf9": 500,
+ "\u221a": 453,
+ "\u010e": 722,
+ "\u0157": 333,
+ "\xd1": 722,
+ "\xf5": 500,
+ "\u0156": 667,
+ "\u013b": 611,
+ "\xc3": 722,
+ "\u0104": 722,
+ "\xc5": 722,
+ "\xd5": 722,
+ "\u017c": 444,
+ "\u011a": 611,
+ "\u012e": 333,
+ "\u0137": 500,
+ "\u2212": 564,
+ "\xce": 333,
+ "\u0148": 500,
+ "\u0163": 278,
+ "\xac": 564,
+ "\xf6": 500,
+ "\xfc": 500,
+ "\u2260": 549,
+ "\u0123": 500,
+ "\xf0": 500,
+ "\u017e": 444,
+ "\u0146": 500,
+ "\xb9": 300,
+ "\u012b": 278,
+ "\u20ac": 500,
+ },
+ ),
+ # Generated from ZapfDingbats.afm
+ # Copyright (c) 1985, 1987, 1988, 1989, 1997 Adobe Systems Incorporated. All Rights Reserved.
+ # ITC Zapf Dingbats is a registered trademark of International Typeface Corporation.
+ "ZapfDingbats": FontDescriptor(
+ name="ZapfDingbats",
+ family="ZapfDingbats",
+ weight="Medium",
+ ascent=0.0,
+ descent=0.0,
+ cap_height=0.0,
+ x_height=0.0,
+ italic_angle=0,
+ flags=4,
+ bbox=(-1.0, -143.0, 981.0, 820.0),
+ character_widths={
+ " ": 790,
+ "\x01": 974,
+ "\x02": 961,
+ "\xca": 974,
+ "\x03": 980,
+ "\x04": 719,
+ "\x05": 789,
+ "w": 790,
+ "v": 791,
+ "u": 690,
+ "\x0b": 960,
+ "\x0c": 939,
+ "\r": 549,
+ "\x0e": 855,
+ "\x0f": 911,
+ "\x10": 933,
+ "i": 911,
+ "\x11": 945,
+ "\x12": 974,
+ "\x13": 755,
+ "\x14": 846,
+ "\x15": 762,
+ "\x16": 761,
+ "\x17": 571,
+ "\x18": 677,
+ "\x19": 763,
+ "\x1a": 760,
+ "\x1b": 759,
+ "\x1c": 754,
+ "\x06": 494,
+ "\x07": 552,
+ "\x08": 537,
+ "\t": 577,
+ "\n": 692,
+ "\x1d": 786,
+ "\x1e": 788,
+ "\x1f": 788,
+ "!": 793,
+ '"': 794,
+ "#": 816,
+ "$": 823,
+ "%": 789,
+ "&": 841,
+ "'": 823,
+ "(": 833,
+ ")": 816,
+ "*": 831,
+ "+": 923,
+ ",": 744,
+ "-": 723,
+ ".": 749,
+ "/": 790,
+ "0": 792,
+ "1": 695,
+ "2": 776,
+ "3": 768,
+ "4": 792,
+ "5": 759,
+ "6": 707,
+ "7": 708,
+ "8": 682,
+ "9": 701,
+ ":": 826,
+ ";": 815,
+ "<": 789,
+ "=": 789,
+ ">": 707,
+ "?": 687,
+ "@": 696,
+ "A": 689,
+ "B": 786,
+ "C": 787,
+ "D": 713,
+ "E": 791,
+ "F": 785,
+ "G": 791,
+ "H": 873,
+ "I": 761,
+ "J": 762,
+ "\xcb": 762,
+ "K": 759,
+ "\xcc": 759,
+ "L": 892,
+ "M": 892,
+ "N": 788,
+ "O": 784,
+ "Q": 438,
+ "R": 138,
+ "S": 277,
+ "T": 415,
+ "a": 392,
+ "b": 392,
+ "c": 668,
+ "d": 668,
+ "Y": 390,
+ "Z": 390,
+ "]": 317,
+ "^": 317,
+ "[": 276,
+ "\\": 276,
+ "\xcd": 509,
+ "U": 509,
+ "\xce": 410,
+ "V": 410,
+ "W": 234,
+ "X": 234,
+ "_": 334,
+ "`": 334,
+ "e": 732,
+ "f": 544,
+ "g": 544,
+ "h": 910,
+ "j": 667,
+ "k": 760,
+ "l": 760,
+ "p": 776,
+ "o": 595,
+ "n": 694,
+ "m": 626,
+ "x": 788,
+ "y": 788,
+ "z": 788,
+ "{": 788,
+ "|": 788,
+ "}": 788,
+ "~": 788,
+ "\x7f": 788,
+ "\x80": 788,
+ "\x81": 788,
+ "\x82": 788,
+ "\x83": 788,
+ "\x84": 788,
+ "\x85": 788,
+ "\x86": 788,
+ "\x87": 788,
+ "\x88": 788,
+ "\x89": 788,
+ "\x8a": 788,
+ "\x8b": 788,
+ "\x8c": 788,
+ "\x8d": 788,
+ "\x8e": 788,
+ "\x8f": 788,
+ "\x90": 788,
+ "\x91": 788,
+ "\x92": 788,
+ "\x93": 788,
+ "\x94": 788,
+ "\x95": 788,
+ "\x96": 788,
+ "\x97": 788,
+ "\x98": 788,
+ "\x99": 788,
+ "\x9a": 788,
+ "\x9b": 788,
+ "\x9c": 788,
+ "\x9d": 788,
+ "\x9e": 788,
+ "\x9f": 788,
+ "\xa0": 894,
+ "\xa1": 838,
+ "\xa3": 1016,
+ "\xa4": 458,
+ "\xc4": 748,
+ "\xa5": 924,
+ "\xc0": 748,
+ "\xa6": 918,
+ "\xa7": 927,
+ "\xa8": 928,
+ "\xa9": 928,
+ "\xaa": 834,
+ "\xab": 873,
+ "\xac": 828,
+ "\xad": 924,
+ "\xa2": 924,
+ "\xae": 917,
+ "\xaf": 930,
+ "\xb0": 931,
+ "\xb1": 463,
+ "\xb2": 883,
+ "\xb3": 836,
+ "\xc1": 836,
+ "\xb4": 867,
+ "\xc7": 867,
+ "\xb5": 696,
+ "\xc8": 696,
+ "\xb6": 874,
+ "\xc9": 874,
+ "\xb7": 760,
+ "\xb8": 946,
+ "\xc5": 771,
+ "\xb9": 865,
+ "\xc2": 771,
+ "\xc6": 888,
+ "\xba": 967,
+ "\xc3": 888,
+ "\xbb": 831,
+ "\xbc": 873,
+ "\xbd": 927,
+ "\xbe": 970,
+ "\xbf": 918,
+ },
+ ),
+}
+
+
+# Add aliases per table H.3 on pp. 1109-1110 of the PDF 1.7 reference
+CORE_FONT_METRICS["Arial"] = CORE_FONT_METRICS["Helvetica"]
+CORE_FONT_METRICS["Arial,Italic"] = CORE_FONT_METRICS["Helvetica-Oblique"]
+CORE_FONT_METRICS["Arial,Bold"] = CORE_FONT_METRICS["Helvetica-Bold"]
+CORE_FONT_METRICS["Arial,BoldItalic"] = CORE_FONT_METRICS["Helvetica-BoldOblique"]
+CORE_FONT_METRICS["CourierNew"] = CORE_FONT_METRICS["Courier"]
+CORE_FONT_METRICS["CourierNew,Italic"] = CORE_FONT_METRICS["Courier-Oblique"]
+CORE_FONT_METRICS["CourierNew,Bold"] = CORE_FONT_METRICS["Courier-Bold"]
+CORE_FONT_METRICS["CourierNew,BoldItalic"] = CORE_FONT_METRICS["Courier-BoldOblique"]
+CORE_FONT_METRICS["TimesNewRoman"] = CORE_FONT_METRICS["Times-Roman"]
+CORE_FONT_METRICS["TimesNewRoman,Italic"] = CORE_FONT_METRICS["Times-Italic"]
+CORE_FONT_METRICS["TimesNewRoman,Bold"] = CORE_FONT_METRICS["Times-Bold"]
+CORE_FONT_METRICS["TimesNewRoman,BoldItalic"] = CORE_FONT_METRICS["Times-BoldItalic"]
diff --git a/venv/lib/python3.12/site-packages/pypdf/_codecs/pdfdoc.py b/venv/lib/python3.12/site-packages/pypdf/_codecs/pdfdoc.py
new file mode 100644
index 0000000..306357a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_codecs/pdfdoc.py
@@ -0,0 +1,264 @@
+# PDFDocEncoding Character Set: Table D.2 of PDF Reference 1.7
+# C.1 Predefined encodings sorted by character name of another PDF reference
+# Some indices have '\u0000' although they should have something else:
+# 22: should be '\u0017'
+_pdfdoc_encoding = [
+ "\u0000",
+ "\u0001",
+ "\u0002",
+ "\u0003",
+ "\u0004",
+ "\u0005",
+ "\u0006",
+ "\u0007", # 0 - 7
+ "\u0008",
+ "\u0009",
+ "\u000a",
+ "\u000b",
+ "\u000c",
+ "\u000d",
+ "\u000e",
+ "\u000f", # 8 - 15
+ "\u0010",
+ "\u0011",
+ "\u0012",
+ "\u0013",
+ "\u0014",
+ "\u0015",
+ "\u0000",
+ "\u0017", # 16 - 23
+ "\u02d8",
+ "\u02c7",
+ "\u02c6",
+ "\u02d9",
+ "\u02dd",
+ "\u02db",
+ "\u02da",
+ "\u02dc", # 24 - 31
+ "\u0020",
+ "\u0021",
+ "\u0022",
+ "\u0023",
+ "\u0024",
+ "\u0025",
+ "\u0026",
+ "\u0027", # 32 - 39
+ "\u0028",
+ "\u0029",
+ "\u002a",
+ "\u002b",
+ "\u002c",
+ "\u002d",
+ "\u002e",
+ "\u002f", # 40 - 47
+ "\u0030",
+ "\u0031",
+ "\u0032",
+ "\u0033",
+ "\u0034",
+ "\u0035",
+ "\u0036",
+ "\u0037", # 48 - 55
+ "\u0038",
+ "\u0039",
+ "\u003a",
+ "\u003b",
+ "\u003c",
+ "\u003d",
+ "\u003e",
+ "\u003f", # 56 - 63
+ "\u0040",
+ "\u0041",
+ "\u0042",
+ "\u0043",
+ "\u0044",
+ "\u0045",
+ "\u0046",
+ "\u0047", # 64 - 71
+ "\u0048",
+ "\u0049",
+ "\u004a",
+ "\u004b",
+ "\u004c",
+ "\u004d",
+ "\u004e",
+ "\u004f", # 72 - 79
+ "\u0050",
+ "\u0051",
+ "\u0052",
+ "\u0053",
+ "\u0054",
+ "\u0055",
+ "\u0056",
+ "\u0057", # 80 - 87
+ "\u0058",
+ "\u0059",
+ "\u005a",
+ "\u005b",
+ "\u005c",
+ "\u005d",
+ "\u005e",
+ "\u005f", # 88 - 95
+ "\u0060",
+ "\u0061",
+ "\u0062",
+ "\u0063",
+ "\u0064",
+ "\u0065",
+ "\u0066",
+ "\u0067", # 96 - 103
+ "\u0068",
+ "\u0069",
+ "\u006a",
+ "\u006b",
+ "\u006c",
+ "\u006d",
+ "\u006e",
+ "\u006f", # 104 - 111
+ "\u0070",
+ "\u0071",
+ "\u0072",
+ "\u0073",
+ "\u0074",
+ "\u0075",
+ "\u0076",
+ "\u0077", # 112 - 119
+ "\u0078",
+ "\u0079",
+ "\u007a",
+ "\u007b",
+ "\u007c",
+ "\u007d",
+ "\u007e",
+ "\u0000", # 120 - 127
+ "\u2022",
+ "\u2020",
+ "\u2021",
+ "\u2026",
+ "\u2014",
+ "\u2013",
+ "\u0192",
+ "\u2044", # 128 - 135
+ "\u2039",
+ "\u203a",
+ "\u2212",
+ "\u2030",
+ "\u201e",
+ "\u201c",
+ "\u201d",
+ "\u2018", # 136 - 143
+ "\u2019",
+ "\u201a",
+ "\u2122",
+ "\ufb01",
+ "\ufb02",
+ "\u0141",
+ "\u0152",
+ "\u0160", # 144 - 151
+ "\u0178",
+ "\u017d",
+ "\u0131",
+ "\u0142",
+ "\u0153",
+ "\u0161",
+ "\u017e",
+ "\u0000", # 152 - 159
+ "\u20ac",
+ "\u00a1",
+ "\u00a2",
+ "\u00a3",
+ "\u00a4",
+ "\u00a5",
+ "\u00a6",
+ "\u00a7", # 160 - 167
+ "\u00a8",
+ "\u00a9",
+ "\u00aa",
+ "\u00ab",
+ "\u00ac",
+ "\u0000",
+ "\u00ae",
+ "\u00af", # 168 - 175
+ "\u00b0",
+ "\u00b1",
+ "\u00b2",
+ "\u00b3",
+ "\u00b4",
+ "\u00b5",
+ "\u00b6",
+ "\u00b7", # 176 - 183
+ "\u00b8",
+ "\u00b9",
+ "\u00ba",
+ "\u00bb",
+ "\u00bc",
+ "\u00bd",
+ "\u00be",
+ "\u00bf", # 184 - 191
+ "\u00c0",
+ "\u00c1",
+ "\u00c2",
+ "\u00c3",
+ "\u00c4",
+ "\u00c5",
+ "\u00c6",
+ "\u00c7", # 192 - 199
+ "\u00c8",
+ "\u00c9",
+ "\u00ca",
+ "\u00cb",
+ "\u00cc",
+ "\u00cd",
+ "\u00ce",
+ "\u00cf", # 200 - 207
+ "\u00d0",
+ "\u00d1",
+ "\u00d2",
+ "\u00d3",
+ "\u00d4",
+ "\u00d5",
+ "\u00d6",
+ "\u00d7", # 208 - 215
+ "\u00d8",
+ "\u00d9",
+ "\u00da",
+ "\u00db",
+ "\u00dc",
+ "\u00dd",
+ "\u00de",
+ "\u00df", # 216 - 223
+ "\u00e0",
+ "\u00e1",
+ "\u00e2",
+ "\u00e3",
+ "\u00e4",
+ "\u00e5",
+ "\u00e6",
+ "\u00e7", # 224 - 231
+ "\u00e8",
+ "\u00e9",
+ "\u00ea",
+ "\u00eb",
+ "\u00ec",
+ "\u00ed",
+ "\u00ee",
+ "\u00ef", # 232 - 239
+ "\u00f0",
+ "\u00f1",
+ "\u00f2",
+ "\u00f3",
+ "\u00f4",
+ "\u00f5",
+ "\u00f6",
+ "\u00f7", # 240 - 247
+ "\u00f8",
+ "\u00f9",
+ "\u00fa",
+ "\u00fb",
+ "\u00fc",
+ "\u00fd",
+ "\u00fe",
+ "\u00ff", # 248 - 255
+]
+
+assert len(_pdfdoc_encoding) == 256
diff --git a/venv/lib/python3.12/site-packages/pypdf/_codecs/std.py b/venv/lib/python3.12/site-packages/pypdf/_codecs/std.py
new file mode 100644
index 0000000..a6057ff
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_codecs/std.py
@@ -0,0 +1,258 @@
+_std_encoding = [
+ "\x00",
+ "\x01",
+ "\x02",
+ "\x03",
+ "\x04",
+ "\x05",
+ "\x06",
+ "\x07",
+ "\x08",
+ "\t",
+ "\n",
+ "\x0b",
+ "\x0c",
+ "\r",
+ "\x0e",
+ "\x0f",
+ "\x10",
+ "\x11",
+ "\x12",
+ "\x13",
+ "\x14",
+ "\x15",
+ "\x16",
+ "\x17",
+ "\x18",
+ "\x19",
+ "\x1a",
+ "\x1b",
+ "\x1c",
+ "\x1d",
+ "\x1e",
+ "\x1f",
+ " ",
+ "!",
+ '"',
+ "#",
+ "$",
+ "%",
+ "&",
+ "’",
+ "(",
+ ")",
+ "*",
+ "+",
+ ",",
+ "-",
+ ".",
+ "/",
+ "0",
+ "1",
+ "2",
+ "3",
+ "4",
+ "5",
+ "6",
+ "7",
+ "8",
+ "9",
+ ":",
+ ";",
+ "<",
+ "=",
+ ">",
+ "?",
+ "@",
+ "A",
+ "B",
+ "C",
+ "D",
+ "E",
+ "F",
+ "G",
+ "H",
+ "I",
+ "J",
+ "K",
+ "L",
+ "M",
+ "N",
+ "O",
+ "P",
+ "Q",
+ "R",
+ "S",
+ "T",
+ "U",
+ "V",
+ "W",
+ "X",
+ "Y",
+ "Z",
+ "[",
+ "\\",
+ "]",
+ "^",
+ "_",
+ "‘",
+ "a",
+ "b",
+ "c",
+ "d",
+ "e",
+ "f",
+ "g",
+ "h",
+ "i",
+ "j",
+ "k",
+ "l",
+ "m",
+ "n",
+ "o",
+ "p",
+ "q",
+ "r",
+ "s",
+ "t",
+ "u",
+ "v",
+ "w",
+ "x",
+ "y",
+ "z",
+ "{",
+ "|",
+ "}",
+ "~",
+ "\x7f",
+ "\x80",
+ "\x81",
+ "\x82",
+ "\x83",
+ "\x84",
+ "\x85",
+ "\x86",
+ "\x87",
+ "\x88",
+ "\x89",
+ "\x8a",
+ "\x8b",
+ "\x8c",
+ "\x8d",
+ "\x8e",
+ "\x8f",
+ "\x90",
+ "\x91",
+ "\x92",
+ "\x93",
+ "\x94",
+ "\x95",
+ "\x96",
+ "\x97",
+ "\x98",
+ "\x99",
+ "\x9a",
+ "\x9b",
+ "\x9c",
+ "\x9d",
+ "\x9e",
+ "\x9f",
+ "\xa0",
+ "¡",
+ "¢",
+ "£",
+ "⁄",
+ "¥",
+ "ƒ",
+ "§",
+ "¤",
+ "'",
+ "“",
+ "«",
+ "‹",
+ "›",
+ "fi",
+ "fl",
+ "°",
+ "–",
+ "†",
+ "‡",
+ "·",
+ "µ",
+ "¶",
+ "•",
+ "‚",
+ "„",
+ "”",
+ "»",
+ "…",
+ "‰",
+ "¾",
+ "¿",
+ "À",
+ "`",
+ "´",
+ "ˆ",
+ "˜",
+ "¯",
+ "˘",
+ "˙",
+ "¨",
+ "É",
+ "˚",
+ "¸",
+ "Ì",
+ "˝",
+ "˛",
+ "ˇ",
+ "—",
+ "Ñ",
+ "Ò",
+ "Ó",
+ "Ô",
+ "Õ",
+ "Ö",
+ "×",
+ "Ø",
+ "Ù",
+ "Ú",
+ "Û",
+ "Ü",
+ "Ý",
+ "Þ",
+ "ß",
+ "à",
+ "Æ",
+ "â",
+ "ª",
+ "ä",
+ "å",
+ "æ",
+ "ç",
+ "Ł",
+ "Ø",
+ "Œ",
+ "º",
+ "ì",
+ "í",
+ "î",
+ "ï",
+ "ð",
+ "æ",
+ "ò",
+ "ó",
+ "ô",
+ "ı",
+ "ö",
+ "÷",
+ "ł",
+ "ø",
+ "œ",
+ "ß",
+ "ü",
+ "ý",
+ "þ",
+ "ÿ",
+]
diff --git a/venv/lib/python3.12/site-packages/pypdf/_codecs/symbol.py b/venv/lib/python3.12/site-packages/pypdf/_codecs/symbol.py
new file mode 100644
index 0000000..4c0d680
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_codecs/symbol.py
@@ -0,0 +1,260 @@
+# manually generated from https://www.unicode.org/Public/MAPPINGS/VENDORS/ADOBE/symbol.txt
+_symbol_encoding = [
+ "\u0000",
+ "\u0001",
+ "\u0002",
+ "\u0003",
+ "\u0004",
+ "\u0005",
+ "\u0006",
+ "\u0007",
+ "\u0008",
+ "\u0009",
+ "\u000A",
+ "\u000B",
+ "\u000C",
+ "\u000D",
+ "\u000E",
+ "\u000F",
+ "\u0010",
+ "\u0011",
+ "\u0012",
+ "\u0013",
+ "\u0014",
+ "\u0015",
+ "\u0016",
+ "\u0017",
+ "\u0018",
+ "\u0019",
+ "\u001A",
+ "\u001B",
+ "\u001C",
+ "\u001D",
+ "\u001E",
+ "\u001F",
+ "\u0020",
+ "\u0021",
+ "\u2200",
+ "\u0023",
+ "\u2203",
+ "\u0025",
+ "\u0026",
+ "\u220B",
+ "\u0028",
+ "\u0029",
+ "\u2217",
+ "\u002B",
+ "\u002C",
+ "\u2212",
+ "\u002E",
+ "\u002F",
+ "\u0030",
+ "\u0031",
+ "\u0032",
+ "\u0033",
+ "\u0034",
+ "\u0035",
+ "\u0036",
+ "\u0037",
+ "\u0038",
+ "\u0039",
+ "\u003A",
+ "\u003B",
+ "\u003C",
+ "\u003D",
+ "\u003E",
+ "\u003F",
+ "\u2245",
+ "\u0391",
+ "\u0392",
+ "\u03A7",
+ "\u0394",
+ "\u0395",
+ "\u03A6",
+ "\u0393",
+ "\u0397",
+ "\u0399",
+ "\u03D1",
+ "\u039A",
+ "\u039B",
+ "\u039C",
+ "\u039D",
+ "\u039F",
+ "\u03A0",
+ "\u0398",
+ "\u03A1",
+ "\u03A3",
+ "\u03A4",
+ "\u03A5",
+ "\u03C2",
+ "\u03A9",
+ "\u039E",
+ "\u03A8",
+ "\u0396",
+ "\u005B",
+ "\u2234",
+ "\u005D",
+ "\u22A5",
+ "\u005F",
+ "\uF8E5",
+ "\u03B1",
+ "\u03B2",
+ "\u03C7",
+ "\u03B4",
+ "\u03B5",
+ "\u03C6",
+ "\u03B3",
+ "\u03B7",
+ "\u03B9",
+ "\u03D5",
+ "\u03BA",
+ "\u03BB",
+ "\u00B5",
+ "\u03BD",
+ "\u03BF",
+ "\u03C0",
+ "\u03B8",
+ "\u03C1",
+ "\u03C3",
+ "\u03C4",
+ "\u03C5",
+ "\u03D6",
+ "\u03C9",
+ "\u03BE",
+ "\u03C8",
+ "\u03B6",
+ "\u007B",
+ "\u007C",
+ "\u007D",
+ "\u223C",
+ "\u007F",
+ "\u0080",
+ "\u0081",
+ "\u0082",
+ "\u0083",
+ "\u0084",
+ "\u0085",
+ "\u0086",
+ "\u0087",
+ "\u0088",
+ "\u0089",
+ "\u008A",
+ "\u008B",
+ "\u008C",
+ "\u008D",
+ "\u008E",
+ "\u008F",
+ "\u0090",
+ "\u0091",
+ "\u0092",
+ "\u0093",
+ "\u0094",
+ "\u0095",
+ "\u0096",
+ "\u0097",
+ "\u0098",
+ "\u0099",
+ "\u009A",
+ "\u009B",
+ "\u009C",
+ "\u009D",
+ "\u009E",
+ "\u009F",
+ "\u20AC",
+ "\u03D2",
+ "\u2032",
+ "\u2264",
+ "\u2044",
+ "\u221E",
+ "\u0192",
+ "\u2663",
+ "\u2666",
+ "\u2665",
+ "\u2660",
+ "\u2194",
+ "\u2190",
+ "\u2191",
+ "\u2192",
+ "\u2193",
+ "\u00B0",
+ "\u00B1",
+ "\u2033",
+ "\u2265",
+ "\u00D7",
+ "\u221D",
+ "\u2202",
+ "\u2022",
+ "\u00F7",
+ "\u2260",
+ "\u2261",
+ "\u2248",
+ "\u2026",
+ "\uF8E6",
+ "\uF8E7",
+ "\u21B5",
+ "\u2135",
+ "\u2111",
+ "\u211C",
+ "\u2118",
+ "\u2297",
+ "\u2295",
+ "\u2205",
+ "\u2229",
+ "\u222A",
+ "\u2283",
+ "\u2287",
+ "\u2284",
+ "\u2282",
+ "\u2286",
+ "\u2208",
+ "\u2209",
+ "\u2220",
+ "\u2207",
+ "\uF6DA",
+ "\uF6D9",
+ "\uF6DB",
+ "\u220F",
+ "\u221A",
+ "\u22C5",
+ "\u00AC",
+ "\u2227",
+ "\u2228",
+ "\u21D4",
+ "\u21D0",
+ "\u21D1",
+ "\u21D2",
+ "\u21D3",
+ "\u25CA",
+ "\u2329",
+ "\uF8E8",
+ "\uF8E9",
+ "\uF8EA",
+ "\u2211",
+ "\uF8EB",
+ "\uF8EC",
+ "\uF8ED",
+ "\uF8EE",
+ "\uF8EF",
+ "\uF8F0",
+ "\uF8F1",
+ "\uF8F2",
+ "\uF8F3",
+ "\uF8F4",
+ "\u00F0",
+ "\u232A",
+ "\u222B",
+ "\u2320",
+ "\uF8F5",
+ "\u2321",
+ "\uF8F6",
+ "\uF8F7",
+ "\uF8F8",
+ "\uF8F9",
+ "\uF8FA",
+ "\uF8FB",
+ "\uF8FC",
+ "\uF8FD",
+ "\uF8FE",
+ "\u00FF",
+]
+assert len(_symbol_encoding) == 256
diff --git a/venv/lib/python3.12/site-packages/pypdf/_codecs/zapfding.py b/venv/lib/python3.12/site-packages/pypdf/_codecs/zapfding.py
new file mode 100644
index 0000000..9b6cdbc
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_codecs/zapfding.py
@@ -0,0 +1,261 @@
+# manually generated from https://www.unicode.org/Public/MAPPINGS/VENDORS/ADOBE/zdingbat.txt
+
+_zapfding_encoding = [
+ "\u0000",
+ "\u0001",
+ "\u0002",
+ "\u0003",
+ "\u0004",
+ "\u0005",
+ "\u0006",
+ "\u0007",
+ "\u0008",
+ "\u0009",
+ "\u000A",
+ "\u000B",
+ "\u000C",
+ "\u000D",
+ "\u000E",
+ "\u000F",
+ "\u0010",
+ "\u0011",
+ "\u0012",
+ "\u0013",
+ "\u0014",
+ "\u0015",
+ "\u0016",
+ "\u0017",
+ "\u0018",
+ "\u0019",
+ "\u001A",
+ "\u001B",
+ "\u001C",
+ "\u001D",
+ "\u001E",
+ "\u001F",
+ "\u0020",
+ "\u2701",
+ "\u2702",
+ "\u2703",
+ "\u2704",
+ "\u260E",
+ "\u2706",
+ "\u2707",
+ "\u2708",
+ "\u2709",
+ "\u261B",
+ "\u261E",
+ "\u270C",
+ "\u270D",
+ "\u270E",
+ "\u270F",
+ "\u2710",
+ "\u2711",
+ "\u2712",
+ "\u2713",
+ "\u2714",
+ "\u2715",
+ "\u2716",
+ "\u2717",
+ "\u2718",
+ "\u2719",
+ "\u271A",
+ "\u271B",
+ "\u271C",
+ "\u271D",
+ "\u271E",
+ "\u271F",
+ "\u2720",
+ "\u2721",
+ "\u2722",
+ "\u2723",
+ "\u2724",
+ "\u2725",
+ "\u2726",
+ "\u2727",
+ "\u2605",
+ "\u2729",
+ "\u272A",
+ "\u272B",
+ "\u272C",
+ "\u272D",
+ "\u272E",
+ "\u272F",
+ "\u2730",
+ "\u2731",
+ "\u2732",
+ "\u2733",
+ "\u2734",
+ "\u2735",
+ "\u2736",
+ "\u2737",
+ "\u2738",
+ "\u2739",
+ "\u273A",
+ "\u273B",
+ "\u273C",
+ "\u273D",
+ "\u273E",
+ "\u273F",
+ "\u2740",
+ "\u2741",
+ "\u2742",
+ "\u2743",
+ "\u2744",
+ "\u2745",
+ "\u2746",
+ "\u2747",
+ "\u2748",
+ "\u2749",
+ "\u274A",
+ "\u274B",
+ "\u25CF",
+ "\u274D",
+ "\u25A0",
+ "\u274F",
+ "\u2750",
+ "\u2751",
+ "\u2752",
+ "\u25B2",
+ "\u25BC",
+ "\u25C6",
+ "\u2756",
+ "\u25D7",
+ "\u2758",
+ "\u2759",
+ "\u275A",
+ "\u275B",
+ "\u275C",
+ "\u275D",
+ "\u275E",
+ "\u007F",
+ "\uF8D7",
+ "\uF8D8",
+ "\uF8D9",
+ "\uF8DA",
+ "\uF8DB",
+ "\uF8DC",
+ "\uF8DD",
+ "\uF8DE",
+ "\uF8DF",
+ "\uF8E0",
+ "\uF8E1",
+ "\uF8E2",
+ "\uF8E3",
+ "\uF8E4",
+ "\u008E",
+ "\u008F",
+ "\u0090",
+ "\u0091",
+ "\u0092",
+ "\u0093",
+ "\u0094",
+ "\u0095",
+ "\u0096",
+ "\u0097",
+ "\u0098",
+ "\u0099",
+ "\u009A",
+ "\u009B",
+ "\u009C",
+ "\u009D",
+ "\u009E",
+ "\u009F",
+ "\u00A0",
+ "\u2761",
+ "\u2762",
+ "\u2763",
+ "\u2764",
+ "\u2765",
+ "\u2766",
+ "\u2767",
+ "\u2663",
+ "\u2666",
+ "\u2665",
+ "\u2660",
+ "\u2460",
+ "\u2461",
+ "\u2462",
+ "\u2463",
+ "\u2464",
+ "\u2465",
+ "\u2466",
+ "\u2467",
+ "\u2468",
+ "\u2469",
+ "\u2776",
+ "\u2777",
+ "\u2778",
+ "\u2779",
+ "\u277A",
+ "\u277B",
+ "\u277C",
+ "\u277D",
+ "\u277E",
+ "\u277F",
+ "\u2780",
+ "\u2781",
+ "\u2782",
+ "\u2783",
+ "\u2784",
+ "\u2785",
+ "\u2786",
+ "\u2787",
+ "\u2788",
+ "\u2789",
+ "\u278A",
+ "\u278B",
+ "\u278C",
+ "\u278D",
+ "\u278E",
+ "\u278F",
+ "\u2790",
+ "\u2791",
+ "\u2792",
+ "\u2793",
+ "\u2794",
+ "\u2192",
+ "\u2194",
+ "\u2195",
+ "\u2798",
+ "\u2799",
+ "\u279A",
+ "\u279B",
+ "\u279C",
+ "\u279D",
+ "\u279E",
+ "\u279F",
+ "\u27A0",
+ "\u27A1",
+ "\u27A2",
+ "\u27A3",
+ "\u27A4",
+ "\u27A5",
+ "\u27A6",
+ "\u27A7",
+ "\u27A8",
+ "\u27A9",
+ "\u27AA",
+ "\u27AB",
+ "\u27AC",
+ "\u27AD",
+ "\u27AE",
+ "\u27AF",
+ "\u00F0",
+ "\u27B1",
+ "\u27B2",
+ "\u27B3",
+ "\u27B4",
+ "\u27B5",
+ "\u27B6",
+ "\u27B7",
+ "\u27B8",
+ "\u27B9",
+ "\u27BA",
+ "\u27BB",
+ "\u27BC",
+ "\u27BD",
+ "\u27BE",
+ "\u00FF",
+]
+assert len(_zapfding_encoding) == 256
diff --git a/venv/lib/python3.12/site-packages/pypdf/_crypt_providers/__init__.py b/venv/lib/python3.12/site-packages/pypdf/_crypt_providers/__init__.py
new file mode 100644
index 0000000..215a258
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_crypt_providers/__init__.py
@@ -0,0 +1,86 @@
+# Copyright (c) 2023, exiledkingcc
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+
+from pypdf._crypt_providers._base import CryptBase, CryptIdentity
+
+try:
+ from pypdf._crypt_providers._cryptography import (
+ CryptAES,
+ CryptRC4,
+ aes_cbc_decrypt,
+ aes_cbc_encrypt,
+ aes_ecb_decrypt,
+ aes_ecb_encrypt,
+ crypt_provider,
+ rc4_decrypt,
+ rc4_encrypt,
+ )
+ from pypdf._utils import Version
+
+ if Version(crypt_provider[1]) <= Version("3.0"):
+ # This is due to the backend parameter being required back then:
+ # https://cryptography.io/en/latest/changelog/#v3-1
+ raise ImportError("cryptography<=3.0 is not supported") # pragma: no cover
+except ImportError:
+ try:
+ from pypdf._crypt_providers._pycryptodome import ( # type: ignore
+ CryptAES,
+ CryptRC4,
+ aes_cbc_decrypt,
+ aes_cbc_encrypt,
+ aes_ecb_decrypt,
+ aes_ecb_encrypt,
+ crypt_provider,
+ rc4_decrypt,
+ rc4_encrypt,
+ )
+ except ImportError:
+ from pypdf._crypt_providers._fallback import ( # type: ignore
+ CryptAES,
+ CryptRC4,
+ aes_cbc_decrypt,
+ aes_cbc_encrypt,
+ aes_ecb_decrypt,
+ aes_ecb_encrypt,
+ crypt_provider,
+ rc4_decrypt,
+ rc4_encrypt,
+ )
+
+__all__ = [
+ "CryptAES",
+ "CryptBase",
+ "CryptIdentity",
+ "CryptRC4",
+ "aes_cbc_decrypt",
+ "aes_cbc_encrypt",
+ "aes_ecb_decrypt",
+ "aes_ecb_encrypt",
+ "crypt_provider",
+ "rc4_decrypt",
+ "rc4_encrypt",
+]
diff --git a/venv/lib/python3.12/site-packages/pypdf/_crypt_providers/_base.py b/venv/lib/python3.12/site-packages/pypdf/_crypt_providers/_base.py
new file mode 100644
index 0000000..894025f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_crypt_providers/_base.py
@@ -0,0 +1,38 @@
+# Copyright (c) 2023, exiledkingcc
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+
+
+class CryptBase:
+ def encrypt(self, data: bytes) -> bytes: # pragma: no cover
+ return data
+
+ def decrypt(self, data: bytes) -> bytes: # pragma: no cover
+ return data
+
+
+class CryptIdentity(CryptBase):
+ pass
diff --git a/venv/lib/python3.12/site-packages/pypdf/_crypt_providers/_cryptography.py b/venv/lib/python3.12/site-packages/pypdf/_crypt_providers/_cryptography.py
new file mode 100644
index 0000000..f553761
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_crypt_providers/_cryptography.py
@@ -0,0 +1,118 @@
+# Copyright (c) 2023, exiledkingcc
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+
+import secrets
+
+from cryptography import __version__
+from cryptography.hazmat.primitives import padding
+from cryptography.hazmat.primitives.ciphers.algorithms import AES
+
+try:
+ # 43.0.0 - https://cryptography.io/en/latest/changelog/#v43-0-0
+ from cryptography.hazmat.decrepit.ciphers.algorithms import ARC4
+except ImportError:
+ from cryptography.hazmat.primitives.ciphers.algorithms import ARC4
+from cryptography.hazmat.primitives.ciphers.base import Cipher
+from cryptography.hazmat.primitives.ciphers.modes import CBC, ECB
+
+from pypdf._crypt_providers._base import CryptBase
+
+crypt_provider = ("cryptography", __version__)
+
+
+class CryptRC4(CryptBase):
+ def __init__(self, key: bytes) -> None:
+ self.cipher = Cipher(ARC4(key), mode=None)
+
+ def encrypt(self, data: bytes) -> bytes:
+ encryptor = self.cipher.encryptor()
+ return encryptor.update(data) + encryptor.finalize()
+
+ def decrypt(self, data: bytes) -> bytes:
+ decryptor = self.cipher.decryptor()
+ return decryptor.update(data) + decryptor.finalize()
+
+
+class CryptAES(CryptBase):
+ def __init__(self, key: bytes) -> None:
+ self.alg = AES(key)
+
+ def encrypt(self, data: bytes) -> bytes:
+ iv = secrets.token_bytes(16)
+ pad = padding.PKCS7(128).padder()
+ data = pad.update(data) + pad.finalize()
+
+ cipher = Cipher(self.alg, CBC(iv))
+ encryptor = cipher.encryptor()
+ return iv + encryptor.update(data) + encryptor.finalize()
+
+ def decrypt(self, data: bytes) -> bytes:
+ iv = data[:16]
+ data = data[16:]
+ # for empty encrypted data
+ if not data:
+ return data
+
+ # just for robustness, it does not happen under normal circumstances
+ if len(data) % 16 != 0:
+ pad = padding.PKCS7(128).padder()
+ data = pad.update(data) + pad.finalize()
+
+ cipher = Cipher(self.alg, CBC(iv))
+ decryptor = cipher.decryptor()
+ d = decryptor.update(data) + decryptor.finalize()
+ return d[: -d[-1]]
+
+
+def rc4_encrypt(key: bytes, data: bytes) -> bytes:
+ encryptor = Cipher(ARC4(key), mode=None).encryptor()
+ return encryptor.update(data) + encryptor.finalize()
+
+
+def rc4_decrypt(key: bytes, data: bytes) -> bytes:
+ decryptor = Cipher(ARC4(key), mode=None).decryptor()
+ return decryptor.update(data) + decryptor.finalize()
+
+
+def aes_ecb_encrypt(key: bytes, data: bytes) -> bytes:
+ encryptor = Cipher(AES(key), mode=ECB()).encryptor()
+ return encryptor.update(data) + encryptor.finalize()
+
+
+def aes_ecb_decrypt(key: bytes, data: bytes) -> bytes:
+ decryptor = Cipher(AES(key), mode=ECB()).decryptor()
+ return decryptor.update(data) + decryptor.finalize()
+
+
+def aes_cbc_encrypt(key: bytes, iv: bytes, data: bytes) -> bytes:
+ encryptor = Cipher(AES(key), mode=CBC(iv)).encryptor()
+ return encryptor.update(data) + encryptor.finalize()
+
+
+def aes_cbc_decrypt(key: bytes, iv: bytes, data: bytes) -> bytes:
+ decryptor = Cipher(AES(key), mode=CBC(iv)).decryptor()
+ return decryptor.update(data) + decryptor.finalize()
diff --git a/venv/lib/python3.12/site-packages/pypdf/_crypt_providers/_fallback.py b/venv/lib/python3.12/site-packages/pypdf/_crypt_providers/_fallback.py
new file mode 100644
index 0000000..0412211
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_crypt_providers/_fallback.py
@@ -0,0 +1,93 @@
+# Copyright (c) 2023, exiledkingcc
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+
+from pypdf._crypt_providers._base import CryptBase
+from pypdf.errors import DependencyError
+
+_DEPENDENCY_ERROR_STR = "cryptography>=3.1 is required for AES algorithm"
+
+
+crypt_provider = ("local_crypt_fallback", "0.0.0")
+
+
+class CryptRC4(CryptBase):
+ def __init__(self, key: bytes) -> None:
+ self.s = bytearray(range(256))
+ j = 0
+ for i in range(256):
+ j = (j + self.s[i] + key[i % len(key)]) % 256
+ self.s[i], self.s[j] = self.s[j], self.s[i]
+
+ def encrypt(self, data: bytes) -> bytes:
+ s = bytearray(self.s)
+ out = [0 for _ in range(len(data))]
+ i, j = 0, 0
+ for k in range(len(data)):
+ i = (i + 1) % 256
+ j = (j + s[i]) % 256
+ s[i], s[j] = s[j], s[i]
+ x = s[(s[i] + s[j]) % 256]
+ out[k] = data[k] ^ x
+ return bytes(out)
+
+ def decrypt(self, data: bytes) -> bytes:
+ return self.encrypt(data)
+
+
+class CryptAES(CryptBase):
+ def __init__(self, key: bytes) -> None:
+ pass
+
+ def encrypt(self, data: bytes) -> bytes:
+ raise DependencyError(_DEPENDENCY_ERROR_STR)
+
+ def decrypt(self, data: bytes) -> bytes:
+ raise DependencyError(_DEPENDENCY_ERROR_STR)
+
+
+def rc4_encrypt(key: bytes, data: bytes) -> bytes:
+ return CryptRC4(key).encrypt(data)
+
+
+def rc4_decrypt(key: bytes, data: bytes) -> bytes:
+ return CryptRC4(key).decrypt(data)
+
+
+def aes_ecb_encrypt(key: bytes, data: bytes) -> bytes:
+ raise DependencyError(_DEPENDENCY_ERROR_STR)
+
+
+def aes_ecb_decrypt(key: bytes, data: bytes) -> bytes:
+ raise DependencyError(_DEPENDENCY_ERROR_STR)
+
+
+def aes_cbc_encrypt(key: bytes, iv: bytes, data: bytes) -> bytes:
+ raise DependencyError(_DEPENDENCY_ERROR_STR)
+
+
+def aes_cbc_decrypt(key: bytes, iv: bytes, data: bytes) -> bytes:
+ raise DependencyError(_DEPENDENCY_ERROR_STR)
diff --git a/venv/lib/python3.12/site-packages/pypdf/_crypt_providers/_pycryptodome.py b/venv/lib/python3.12/site-packages/pypdf/_crypt_providers/_pycryptodome.py
new file mode 100644
index 0000000..30a13e1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_crypt_providers/_pycryptodome.py
@@ -0,0 +1,97 @@
+# Copyright (c) 2023, exiledkingcc
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+
+import secrets
+
+from Crypto import __version__
+from Crypto.Cipher import AES, ARC4
+from Crypto.Util.Padding import pad
+
+from pypdf._crypt_providers._base import CryptBase
+
+crypt_provider = ("pycryptodome", __version__)
+
+
+class CryptRC4(CryptBase):
+ def __init__(self, key: bytes) -> None:
+ self.key = key
+
+ def encrypt(self, data: bytes) -> bytes:
+ return ARC4.ARC4Cipher(self.key).encrypt(data)
+
+ def decrypt(self, data: bytes) -> bytes:
+ return ARC4.ARC4Cipher(self.key).decrypt(data)
+
+
+class CryptAES(CryptBase):
+ def __init__(self, key: bytes) -> None:
+ self.key = key
+
+ def encrypt(self, data: bytes) -> bytes:
+ iv = secrets.token_bytes(16)
+ data = pad(data, 16)
+ aes = AES.new(self.key, AES.MODE_CBC, iv)
+ return iv + aes.encrypt(data)
+
+ def decrypt(self, data: bytes) -> bytes:
+ iv = data[:16]
+ data = data[16:]
+ # for empty encrypted data
+ if not data:
+ return data
+
+ # just for robustness, it does not happen under normal circumstances
+ if len(data) % 16 != 0:
+ data = pad(data, 16)
+
+ aes = AES.new(self.key, AES.MODE_CBC, iv)
+ d = aes.decrypt(data)
+ return d[: -d[-1]]
+
+
+def rc4_encrypt(key: bytes, data: bytes) -> bytes:
+ return ARC4.ARC4Cipher(key).encrypt(data)
+
+
+def rc4_decrypt(key: bytes, data: bytes) -> bytes:
+ return ARC4.ARC4Cipher(key).decrypt(data)
+
+
+def aes_ecb_encrypt(key: bytes, data: bytes) -> bytes:
+ return AES.new(key, AES.MODE_ECB).encrypt(data)
+
+
+def aes_ecb_decrypt(key: bytes, data: bytes) -> bytes:
+ return AES.new(key, AES.MODE_ECB).decrypt(data)
+
+
+def aes_cbc_encrypt(key: bytes, iv: bytes, data: bytes) -> bytes:
+ return AES.new(key, AES.MODE_CBC, iv).encrypt(data)
+
+
+def aes_cbc_decrypt(key: bytes, iv: bytes, data: bytes) -> bytes:
+ return AES.new(key, AES.MODE_CBC, iv).decrypt(data)
diff --git a/venv/lib/python3.12/site-packages/pypdf/_doc_common.py b/venv/lib/python3.12/site-packages/pypdf/_doc_common.py
new file mode 100644
index 0000000..8602b19
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_doc_common.py
@@ -0,0 +1,1461 @@
+# Copyright (c) 2006, Mathieu Fenniak
+# Copyright (c) 2007, Ashish Kulkarni
+# Copyright (c) 2024, Pubpub-ZZ
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+
+import struct
+import zlib
+from abc import abstractmethod
+from collections.abc import Generator, Iterable, Iterator, Mapping
+from datetime import datetime
+from typing import (
+ Any,
+ Optional,
+ Union,
+ cast,
+)
+
+from ._encryption import Encryption
+from ._page import PageObject, _VirtualList
+from ._page_labels import index2label as page_index2page_label
+from ._utils import (
+ deprecation_with_replacement,
+ logger_warning,
+ parse_iso8824_date,
+)
+from .constants import CatalogAttributes as CA
+from .constants import CatalogDictionary as CD
+from .constants import (
+ CheckboxRadioButtonAttributes,
+ GoToActionArguments,
+ PagesAttributes,
+ UserAccessPermissions,
+)
+from .constants import Core as CO
+from .constants import DocumentInformationAttributes as DI
+from .constants import FieldDictionaryAttributes as FA
+from .constants import PageAttributes as PG
+from .errors import PdfReadError, PyPdfError
+from .generic import (
+ ArrayObject,
+ BooleanObject,
+ ByteStringObject,
+ Destination,
+ DictionaryObject,
+ EncodedStreamObject,
+ Field,
+ Fit,
+ FloatObject,
+ IndirectObject,
+ NameObject,
+ NullObject,
+ NumberObject,
+ PdfObject,
+ TextStringObject,
+ TreeObject,
+ ViewerPreferences,
+ create_string_object,
+ is_null_or_none,
+)
+from .generic._files import EmbeddedFile
+from .types import OutlineType, PagemodeType
+from .xmp import XmpInformation
+
+
+def convert_to_int(d: bytes, size: int) -> Union[int, tuple[Any, ...]]:
+ if size > 8:
+ raise PdfReadError("Invalid size in convert_to_int")
+ d = b"\x00\x00\x00\x00\x00\x00\x00\x00" + d
+ d = d[-8:]
+ return struct.unpack(">q", d)[0]
+
+
+class DocumentInformation(DictionaryObject):
+ """
+ A class representing the basic document metadata provided in a PDF File.
+ This class is accessible through
+ :py:class:`PdfReader.metadata`.
+
+ All text properties of the document metadata have
+ *two* properties, e.g. author and author_raw. The non-raw property will
+ always return a ``TextStringObject``, making it ideal for a case where the
+ metadata is being displayed. The raw property can sometimes return a
+ ``ByteStringObject``, if pypdf was unable to decode the string's text
+ encoding; this requires additional safety in the caller and therefore is not
+ as commonly accessed.
+ """
+
+ def __init__(self) -> None:
+ DictionaryObject.__init__(self)
+
+ def _get_text(self, key: str) -> Optional[str]:
+ retval = self.get(key, None)
+ if isinstance(retval, TextStringObject):
+ return retval
+ if isinstance(retval, ByteStringObject):
+ return str(retval)
+ return None
+
+ @property
+ def title(self) -> Optional[str]:
+ """
+ Read-only property accessing the document's title.
+
+ Returns a ``TextStringObject`` or ``None`` if the title is not
+ specified.
+ """
+ return (
+ self._get_text(DI.TITLE) or self.get(DI.TITLE).get_object() # type: ignore
+ if self.get(DI.TITLE)
+ else None
+ )
+
+ @property
+ def title_raw(self) -> Optional[str]:
+ """The "raw" version of title; can return a ``ByteStringObject``."""
+ return self.get(DI.TITLE)
+
+ @property
+ def author(self) -> Optional[str]:
+ """
+ Read-only property accessing the document's author.
+
+ Returns a ``TextStringObject`` or ``None`` if the author is not
+ specified.
+ """
+ return self._get_text(DI.AUTHOR)
+
+ @property
+ def author_raw(self) -> Optional[str]:
+ """The "raw" version of author; can return a ``ByteStringObject``."""
+ return self.get(DI.AUTHOR)
+
+ @property
+ def subject(self) -> Optional[str]:
+ """
+ Read-only property accessing the document's subject.
+
+ Returns a ``TextStringObject`` or ``None`` if the subject is not
+ specified.
+ """
+ return self._get_text(DI.SUBJECT)
+
+ @property
+ def subject_raw(self) -> Optional[str]:
+ """The "raw" version of subject; can return a ``ByteStringObject``."""
+ return self.get(DI.SUBJECT)
+
+ @property
+ def creator(self) -> Optional[str]:
+ """
+ Read-only property accessing the document's creator.
+
+ If the document was converted to PDF from another format, this is the
+ name of the application (e.g. OpenOffice) that created the original
+ document from which it was converted. Returns a ``TextStringObject`` or
+ ``None`` if the creator is not specified.
+ """
+ return self._get_text(DI.CREATOR)
+
+ @property
+ def creator_raw(self) -> Optional[str]:
+ """The "raw" version of creator; can return a ``ByteStringObject``."""
+ return self.get(DI.CREATOR)
+
+ @property
+ def producer(self) -> Optional[str]:
+ """
+ Read-only property accessing the document's producer.
+
+ If the document was converted to PDF from another format, this is the
+ name of the application (for example, macOS Quartz) that converted it to
+ PDF. Returns a ``TextStringObject`` or ``None`` if the producer is not
+ specified.
+ """
+ return self._get_text(DI.PRODUCER)
+
+ @property
+ def producer_raw(self) -> Optional[str]:
+ """The "raw" version of producer; can return a ``ByteStringObject``."""
+ return self.get(DI.PRODUCER)
+
+ @property
+ def creation_date(self) -> Optional[datetime]:
+ """Read-only property accessing the document's creation date."""
+ return parse_iso8824_date(self._get_text(DI.CREATION_DATE))
+
+ @property
+ def creation_date_raw(self) -> Optional[str]:
+ """
+ The "raw" version of creation date; can return a ``ByteStringObject``.
+
+ Typically in the format ``D:YYYYMMDDhhmmss[+Z-]hh'mm`` where the suffix
+ is the offset from UTC.
+ """
+ return self.get(DI.CREATION_DATE)
+
+ @property
+ def modification_date(self) -> Optional[datetime]:
+ """
+ Read-only property accessing the document's modification date.
+
+ The date and time the document was most recently modified.
+ """
+ return parse_iso8824_date(self._get_text(DI.MOD_DATE))
+
+ @property
+ def modification_date_raw(self) -> Optional[str]:
+ """
+ The "raw" version of modification date; can return a
+ ``ByteStringObject``.
+
+ Typically in the format ``D:YYYYMMDDhhmmss[+Z-]hh'mm`` where the suffix
+ is the offset from UTC.
+ """
+ return self.get(DI.MOD_DATE)
+
+ @property
+ def keywords(self) -> Optional[str]:
+ """
+ Read-only property accessing the document's keywords.
+
+ Returns a ``TextStringObject`` or ``None`` if keywords are not
+ specified.
+ """
+ return self._get_text(DI.KEYWORDS)
+
+ @property
+ def keywords_raw(self) -> Optional[str]:
+ """The "raw" version of keywords; can return a ``ByteStringObject``."""
+ return self.get(DI.KEYWORDS)
+
+
+class PdfDocCommon:
+ """
+ Common functions from PdfWriter and PdfReader objects.
+
+ This root class is strongly abstracted.
+ """
+
+ strict: bool = False # default
+
+ flattened_pages: Optional[list[PageObject]] = None
+
+ _encryption: Optional[Encryption] = None
+
+ _readonly: bool = False
+
+ @property
+ @abstractmethod
+ def root_object(self) -> DictionaryObject:
+ ... # pragma: no cover
+
+ @property
+ @abstractmethod
+ def pdf_header(self) -> str:
+ ... # pragma: no cover
+
+ @abstractmethod
+ def get_object(
+ self, indirect_reference: Union[int, IndirectObject]
+ ) -> Optional[PdfObject]:
+ ... # pragma: no cover
+
+ @abstractmethod
+ def _replace_object(self, indirect: IndirectObject, obj: PdfObject) -> PdfObject:
+ ... # pragma: no cover
+
+ @property
+ @abstractmethod
+ def _info(self) -> Optional[DictionaryObject]:
+ ... # pragma: no cover
+
+ @property
+ def metadata(self) -> Optional[DocumentInformation]:
+ """
+ Retrieve the PDF file's document information dictionary, if it exists.
+
+ Note that some PDF files use metadata streams instead of document
+ information dictionaries, and these metadata streams will not be
+ accessed by this function.
+ """
+ retval = DocumentInformation()
+ if self._info is None:
+ return None
+ retval.update(self._info)
+ return retval
+
+ @property
+ def xmp_metadata(self) -> Optional[XmpInformation]:
+ ... # pragma: no cover
+
+ @property
+ def viewer_preferences(self) -> Optional[ViewerPreferences]:
+ """Returns the existing ViewerPreferences as an overloaded dictionary."""
+ o = self.root_object.get(CD.VIEWER_PREFERENCES, None)
+ if o is None:
+ return None
+ o = o.get_object()
+ if not isinstance(o, ViewerPreferences):
+ o = ViewerPreferences(o)
+ if hasattr(o, "indirect_reference") and o.indirect_reference is not None:
+ self._replace_object(o.indirect_reference, o)
+ else:
+ self.root_object[NameObject(CD.VIEWER_PREFERENCES)] = o
+ return o
+
+ def get_num_pages(self) -> int:
+ """
+ Calculate the number of pages in this PDF file.
+
+ Returns:
+ The number of pages of the parsed PDF file.
+
+ Raises:
+ PdfReadError: If restrictions prevent this action.
+
+ """
+ # Flattened pages will not work on an encrypted PDF;
+ # the PDF file's page count is used in this case. Otherwise,
+ # the original method (flattened page count) is used.
+ if self.is_encrypted:
+ return self.root_object["/Pages"]["/Count"] # type: ignore
+ if self.flattened_pages is None:
+ self._flatten(self._readonly)
+ assert self.flattened_pages is not None
+ return len(self.flattened_pages)
+
+ def get_page(self, page_number: int) -> PageObject:
+ """
+ Retrieve a page by number from this PDF file.
+ Most of the time ``.pages[page_number]`` is preferred.
+
+ Args:
+ page_number: The page number to retrieve
+ (pages begin at zero)
+
+ Returns:
+ A :class:`PageObject` instance.
+
+ """
+ if self.flattened_pages is None:
+ self._flatten(self._readonly)
+ assert self.flattened_pages is not None, "hint for mypy"
+ return self.flattened_pages[page_number]
+
+ def _get_page_in_node(
+ self,
+ page_number: int,
+ ) -> tuple[DictionaryObject, int]:
+ """
+ Retrieve the node and position within the /Kids containing the page.
+ If page_number is greater than the number of pages, it returns the top node, -1.
+ """
+ top = cast(DictionaryObject, self.root_object["/Pages"])
+
+ def recursive_call(
+ node: DictionaryObject, mi: int
+ ) -> tuple[Optional[PdfObject], int]:
+ ma = cast(int, node.get("/Count", 1)) # default 1 for /Page types
+ if node["/Type"] == "/Page":
+ if page_number == mi:
+ return node, -1
+ return None, mi + 1
+ if (page_number - mi) >= ma: # not in nodes below
+ if node == top:
+ return top, -1
+ return None, mi + ma
+ for idx, kid in enumerate(cast(ArrayObject, node["/Kids"])):
+ kid = cast(DictionaryObject, kid.get_object())
+ n, i = recursive_call(kid, mi)
+ if n is not None: # page has just been found ...
+ if i < 0: # ... just below!
+ return node, idx
+ # ... at lower levels
+ return n, i
+ mi = i
+ raise PyPdfError("Unexpectedly cannot find the node.")
+
+ node, idx = recursive_call(top, 0)
+ assert isinstance(node, DictionaryObject), "mypy"
+ return node, idx
+
+ @property
+ def named_destinations(self) -> dict[str, Destination]:
+ """A read-only dictionary which maps names to destinations."""
+ return self._get_named_destinations()
+
+ def get_named_dest_root(self) -> ArrayObject:
+ named_dest = ArrayObject()
+ if CA.NAMES in self.root_object and isinstance(
+ self.root_object[CA.NAMES], DictionaryObject
+ ):
+ names = cast(DictionaryObject, self.root_object[CA.NAMES])
+ if CA.DESTS in names and isinstance(names[CA.DESTS], DictionaryObject):
+ # §3.6.3 Name Dictionary (PDF spec 1.7)
+ dests = cast(DictionaryObject, names[CA.DESTS])
+ dests_ref = dests.indirect_reference
+ if CA.NAMES in dests:
+ # §7.9.6, entries in a name tree node dictionary
+ named_dest = cast(ArrayObject, dests[CA.NAMES])
+ else:
+ named_dest = ArrayObject()
+ dests[NameObject(CA.NAMES)] = named_dest
+ elif hasattr(self, "_add_object"):
+ dests = DictionaryObject()
+ dests_ref = self._add_object(dests)
+ names[NameObject(CA.DESTS)] = dests_ref
+ dests[NameObject(CA.NAMES)] = named_dest
+
+ elif hasattr(self, "_add_object"):
+ names = DictionaryObject()
+ names_ref = self._add_object(names)
+ self.root_object[NameObject(CA.NAMES)] = names_ref
+ dests = DictionaryObject()
+ dests_ref = self._add_object(dests)
+ names[NameObject(CA.DESTS)] = dests_ref
+ dests[NameObject(CA.NAMES)] = named_dest
+
+ return named_dest
+
+ ## common
+ def _get_named_destinations(
+ self,
+ tree: Union[TreeObject, None] = None,
+ retval: Optional[dict[str, Destination]] = None,
+ ) -> dict[str, Destination]:
+ """
+ Retrieve the named destinations present in the document.
+
+ Args:
+ tree: The current tree.
+ retval: The previously retrieved destinations for nested calls.
+
+ Returns:
+ A dictionary which maps names to destinations.
+
+ """
+ if retval is None:
+ retval = {}
+ catalog = self.root_object
+
+ # get the name tree
+ if CA.DESTS in catalog:
+ tree = cast(TreeObject, catalog[CA.DESTS])
+ elif CA.NAMES in catalog:
+ names = cast(DictionaryObject, catalog[CA.NAMES])
+ if CA.DESTS in names:
+ tree = cast(TreeObject, names[CA.DESTS])
+
+ if is_null_or_none(tree):
+ return retval
+ assert tree is not None, "mypy"
+
+ if PagesAttributes.KIDS in tree:
+ # recurse down the tree
+ for kid in cast(ArrayObject, tree[PagesAttributes.KIDS]):
+ self._get_named_destinations(kid.get_object(), retval)
+ # §7.9.6, entries in a name tree node dictionary
+ elif CA.NAMES in tree: # /Kids and /Names are exclusives (§7.9.6)
+ names = cast(DictionaryObject, tree[CA.NAMES])
+ i = 0
+ while i < len(names):
+ key = names[i].get_object()
+ i += 1
+ if not isinstance(key, (bytes, str)):
+ continue
+ try:
+ value = names[i].get_object()
+ except IndexError:
+ break
+ i += 1
+ if isinstance(value, DictionaryObject):
+ if "/D" in value:
+ value = value["/D"]
+ else:
+ continue
+ dest = self._build_destination(key, value)
+ if dest is not None:
+ retval[cast(str, dest["/Title"])] = dest
+ # Remain backwards-compatible.
+ retval[str(key)] = dest
+ else: # case where Dests is in root catalog (PDF 1.7 specs, §2 about PDF 1.1)
+ for k__, v__ in tree.items():
+ val = v__.get_object()
+ if isinstance(val, DictionaryObject):
+ if "/D" in val:
+ val = val["/D"].get_object()
+ else:
+ continue
+ dest = self._build_destination(k__, val)
+ if dest is not None:
+ retval[k__] = dest
+ return retval
+
+ # A select group of relevant field attributes. For the complete list,
+ # see §12.3.2 of the PDF 1.7 or PDF 2.0 specification.
+
+ def get_fields(
+ self,
+ tree: Optional[TreeObject] = None,
+ retval: Optional[dict[Any, Any]] = None,
+ fileobj: Optional[Any] = None,
+ stack: Optional[list[PdfObject]] = None,
+ ) -> Optional[dict[str, Any]]:
+ """
+ Extract field data if this PDF contains interactive form fields.
+
+ The *tree*, *retval*, *stack* parameters are for recursive use.
+
+ Args:
+ tree: Current object to parse.
+ retval: In-progress list of fields.
+ fileobj: A file object (usually a text file) to write
+ a report to on all interactive form fields found.
+ stack: List of already parsed objects.
+
+ Returns:
+ A dictionary where each key is a field name, and each
+ value is a :class:`Field` object. By
+ default, the mapping name is used for keys.
+ ``None`` if form data could not be located.
+
+ """
+ field_attributes = FA.attributes_dict()
+ field_attributes.update(CheckboxRadioButtonAttributes.attributes_dict())
+ if retval is None:
+ retval = {}
+ catalog = self.root_object
+ stack = []
+ # get the AcroForm tree
+ if CD.ACRO_FORM in catalog:
+ tree = cast(Optional[TreeObject], catalog[CD.ACRO_FORM])
+ else:
+ return None
+ if tree is None:
+ return retval
+ assert stack is not None
+ if "/Fields" in tree:
+ fields = cast(ArrayObject, tree["/Fields"])
+ for f in fields:
+ field = f.get_object()
+ self._build_field(field, retval, fileobj, field_attributes, stack)
+ elif any(attr in tree for attr in field_attributes):
+ # Tree is a field
+ self._build_field(tree, retval, fileobj, field_attributes, stack)
+ return retval
+
+ def _get_qualified_field_name(self, parent: DictionaryObject) -> str:
+ if "/TM" in parent:
+ return cast(str, parent["/TM"])
+ if "/Parent" in parent:
+ return (
+ self._get_qualified_field_name(
+ cast(DictionaryObject, parent["/Parent"])
+ )
+ + "."
+ + cast(str, parent.get("/T", ""))
+ )
+ return cast(str, parent.get("/T", ""))
+
+ def _build_field(
+ self,
+ field: Union[TreeObject, DictionaryObject],
+ retval: dict[Any, Any],
+ fileobj: Any,
+ field_attributes: Any,
+ stack: list[PdfObject],
+ ) -> None:
+ if all(attr not in field for attr in ("/T", "/TM")):
+ return
+ key = self._get_qualified_field_name(field)
+ if fileobj:
+ self._write_field(fileobj, field, field_attributes)
+ fileobj.write("\n")
+ retval[key] = Field(field)
+ obj = retval[key].indirect_reference.get_object() # to get the full object
+ if obj.get(FA.FT, "") == "/Ch" and obj.get(NameObject(FA.Opt)):
+ retval[key][NameObject("/_States_")] = obj[NameObject(FA.Opt)]
+ if obj.get(FA.FT, "") == "/Btn" and "/AP" in obj:
+ # Checkbox
+ retval[key][NameObject("/_States_")] = ArrayObject(
+ list(obj["/AP"]["/N"].keys())
+ )
+ if "/Off" not in retval[key]["/_States_"]:
+ retval[key][NameObject("/_States_")].append(NameObject("/Off"))
+ elif obj.get(FA.FT, "") == "/Btn" and obj.get(FA.Ff, 0) & FA.FfBits.Radio != 0:
+ states: list[str] = []
+ retval[key][NameObject("/_States_")] = ArrayObject(states)
+ for k in obj.get(FA.Kids, {}):
+ k = k.get_object()
+ for s in list(k["/AP"]["/N"].keys()):
+ if s not in states:
+ states.append(s)
+ retval[key][NameObject("/_States_")] = ArrayObject(states)
+ if (
+ obj.get(FA.Ff, 0) & FA.FfBits.NoToggleToOff != 0
+ and "/Off" in retval[key]["/_States_"]
+ ):
+ del retval[key]["/_States_"][retval[key]["/_States_"].index("/Off")]
+ # at last for order
+ self._check_kids(field, retval, fileobj, stack)
+
+ def _check_kids(
+ self,
+ tree: Union[TreeObject, DictionaryObject],
+ retval: Any,
+ fileobj: Any,
+ stack: list[PdfObject],
+ ) -> None:
+ if tree in stack:
+ logger_warning(
+ f"{self._get_qualified_field_name(tree)} already parsed", __name__
+ )
+ return
+ stack.append(tree)
+ if PagesAttributes.KIDS in tree:
+ # recurse down the tree
+ for kid in tree[PagesAttributes.KIDS]: # type: ignore
+ kid = kid.get_object()
+ self.get_fields(kid, retval, fileobj, stack)
+
+ def _write_field(self, fileobj: Any, field: Any, field_attributes: Any) -> None:
+ field_attributes_tuple = FA.attributes()
+ field_attributes_tuple = (
+ field_attributes_tuple + CheckboxRadioButtonAttributes.attributes()
+ )
+
+ for attr in field_attributes_tuple:
+ if attr in (
+ FA.Kids,
+ FA.AA,
+ ):
+ continue
+ attr_name = field_attributes[attr]
+ try:
+ if attr == FA.FT:
+ # Make the field type value clearer
+ types = {
+ "/Btn": "Button",
+ "/Tx": "Text",
+ "/Ch": "Choice",
+ "/Sig": "Signature",
+ }
+ if field[attr] in types:
+ fileobj.write(f"{attr_name}: {types[field[attr]]}\n")
+ elif attr == FA.Parent:
+ # Let's just write the name of the parent
+ try:
+ name = field[attr][FA.TM]
+ except KeyError:
+ name = field[attr][FA.T]
+ fileobj.write(f"{attr_name}: {name}\n")
+ else:
+ fileobj.write(f"{attr_name}: {field[attr]}\n")
+ except KeyError:
+ # Field attribute is N/A or unknown, so don't write anything
+ pass
+
+ def get_form_text_fields(self, full_qualified_name: bool = False) -> dict[str, Any]:
+ """
+ Retrieve form fields from the document with textual data.
+
+ Args:
+ full_qualified_name: to get full name
+
+ Returns:
+ A dictionary. The key is the name of the form field,
+ the value is the content of the field.
+
+ If the document contains multiple form fields with the same name, the
+ second and following will get the suffix .2, .3, ...
+
+ """
+
+ def indexed_key(k: str, fields: dict[Any, Any]) -> str:
+ if k not in fields:
+ return k
+ return (
+ k
+ + "."
+ + str(sum(1 for kk in fields if kk.startswith(k + ".")) + 2)
+ )
+
+ # Retrieve document form fields
+ formfields = self.get_fields()
+ if formfields is None:
+ return {}
+ ff = {}
+ for field, value in formfields.items():
+ if value.get("/FT") == "/Tx":
+ if full_qualified_name:
+ ff[field] = value.get("/V")
+ else:
+ ff[indexed_key(cast(str, value["/T"]), ff)] = value.get("/V")
+ return ff
+
+ def get_pages_showing_field(
+ self, field: Union[Field, PdfObject, IndirectObject]
+ ) -> list[PageObject]:
+ """
+ Provides list of pages where the field is called.
+
+ Args:
+ field: Field Object, PdfObject or IndirectObject referencing a Field
+
+ Returns:
+ List of pages:
+ - Empty list:
+ The field has no widgets attached
+ (either hidden field or ancestor field).
+ - Single page list:
+ Page where the widget is present
+ (most common).
+ - Multi-page list:
+ Field with multiple kids widgets
+ (example: radio buttons, field repeated on multiple pages).
+
+ """
+
+ def _get_inherited(obj: DictionaryObject, key: str) -> Any:
+ if key in obj:
+ return obj[key]
+ if "/Parent" in obj:
+ return _get_inherited(
+ cast(DictionaryObject, obj["/Parent"].get_object()), key
+ )
+ return None
+
+ try:
+ # to cope with all types
+ field = cast(DictionaryObject, field.indirect_reference.get_object()) # type: ignore
+ except Exception as exc:
+ raise ValueError("Field type is invalid") from exc
+ if is_null_or_none(_get_inherited(field, "/FT")):
+ raise ValueError("Field is not valid")
+ ret = []
+ if field.get("/Subtype", "") == "/Widget":
+ if "/P" in field:
+ ret = [field["/P"].get_object()]
+ else:
+ ret = [
+ p
+ for p in self.pages
+ if field.indirect_reference in p.get("/Annots", "")
+ ]
+ else:
+ kids = field.get("/Kids", ())
+ for k in kids:
+ k = k.get_object()
+ if (k.get("/Subtype", "") == "/Widget") and ("/T" not in k):
+ # Kid that is just a widget, not a field:
+ if "/P" in k:
+ ret += [k["/P"].get_object()]
+ else:
+ ret += [
+ p
+ for p in self.pages
+ if k.indirect_reference in p.get("/Annots", "")
+ ]
+ return [
+ x
+ if isinstance(x, PageObject)
+ else (self.pages[self._get_page_number_by_indirect(x.indirect_reference)]) # type: ignore
+ for x in ret
+ ]
+
+ @property
+ def open_destination(
+ self,
+ ) -> Union[None, Destination, TextStringObject, ByteStringObject]:
+ """
+ Property to access the opening destination (``/OpenAction`` entry in
+ the PDF catalog). It returns ``None`` if the entry does not exist
+ or is not set.
+
+ Raises:
+ Exception: If a destination is invalid.
+
+ """
+ if "/OpenAction" not in self.root_object:
+ return None
+ oa: Any = self.root_object["/OpenAction"]
+ if isinstance(oa, bytes): # pragma: no cover
+ oa = oa.decode()
+ if isinstance(oa, str):
+ return create_string_object(oa)
+ if isinstance(oa, ArrayObject):
+ try:
+ page, typ, *array = oa
+ fit = Fit(typ, tuple(array))
+ return Destination("OpenAction", page, fit)
+ except Exception as exc:
+ raise Exception(f"Invalid Destination {oa}: {exc}")
+ else:
+ return None
+
+ @open_destination.setter
+ def open_destination(self, dest: Union[None, str, Destination, PageObject]) -> None:
+ raise NotImplementedError("No setter for open_destination")
+
+ @property
+ def outline(self) -> OutlineType:
+ """
+ Read-only property for the outline present in the document
+ (i.e., a collection of 'outline items' which are also known as
+ 'bookmarks').
+ """
+ return self._get_outline()
+
+ def _get_outline(
+ self,
+ node: Optional[DictionaryObject] = None,
+ outline: Optional[Any] = None,
+ visited: Optional[set[int]] = None,
+ ) -> OutlineType:
+ if outline is None:
+ outline = []
+ catalog = self.root_object
+
+ # get the outline dictionary and named destinations
+ if CO.OUTLINES in catalog:
+ lines = cast(DictionaryObject, catalog[CO.OUTLINES])
+
+ if isinstance(lines, NullObject):
+ return outline
+
+ # §12.3.3 Document outline, entries in the outline dictionary
+ if not is_null_or_none(lines) and "/First" in lines:
+ node = cast(DictionaryObject, lines["/First"])
+ self._named_destinations = self._get_named_destinations()
+
+ if node is None:
+ return outline
+
+ # see if there are any more outline items
+ if visited is None:
+ visited = set()
+ while True:
+ node_id = id(node)
+ if node_id in visited:
+ logger_warning(f"Detected cycle in outline structure for {node}", __name__)
+ break
+ visited.add(node_id)
+
+ outline_obj = self._build_outline_item(node)
+ if outline_obj:
+ outline.append(outline_obj)
+
+ # check for sub-outline
+ if "/First" in node:
+ sub_outline: list[Any] = []
+ # Pass a copy to allow multiple outer entries to reference the same inner one.
+ inner_visited = visited.copy()
+ self._get_outline(
+ node=cast(DictionaryObject, node["/First"]),
+ outline=sub_outline,
+ visited=inner_visited,
+ )
+ if sub_outline:
+ outline.append(sub_outline)
+
+ if "/Next" not in node:
+ break
+ node = cast(DictionaryObject, node["/Next"])
+
+ return outline
+
+ @property
+ def threads(self) -> Optional[ArrayObject]:
+ """
+ Read-only property for the list of threads.
+
+ See §12.4.3 from the PDF 1.7 or 2.0 specification.
+
+ It is an array of dictionaries with "/F" (the first bead in the thread)
+ and "/I" (a thread information dictionary containing information about
+ the thread, such as its title, author, and creation date) properties or
+ None if there are no articles.
+
+ Since PDF 2.0 it can also contain an indirect reference to a metadata
+ stream containing information about the thread, such as its title,
+ author, and creation date.
+ """
+ catalog = self.root_object
+ if CO.THREADS in catalog:
+ return cast("ArrayObject", catalog[CO.THREADS])
+ return None
+
+ @abstractmethod
+ def _get_page_number_by_indirect(
+ self, indirect_reference: Union[None, int, NullObject, IndirectObject]
+ ) -> Optional[int]:
+ ... # pragma: no cover
+
+ def get_page_number(self, page: PageObject) -> Optional[int]:
+ """
+ Retrieve page number of a given PageObject.
+
+ Args:
+ page: The page to get page number. Should be
+ an instance of :class:`PageObject`
+
+ Returns:
+ The page number or None if page is not found
+
+ """
+ return self._get_page_number_by_indirect(page.indirect_reference)
+
+ def get_destination_page_number(self, destination: Destination) -> Optional[int]:
+ """
+ Retrieve page number of a given Destination object.
+
+ Args:
+ destination: The destination to get page number.
+
+ Returns:
+ The page number or None if page is not found
+
+ """
+ return self._get_page_number_by_indirect(destination.page)
+
+ def _build_destination(
+ self,
+ title: Union[str, bytes],
+ array: Optional[
+ list[
+ Union[NumberObject, IndirectObject, None, NullObject, DictionaryObject]
+ ]
+ ],
+ ) -> Destination:
+ page, typ = None, None
+ # handle outline items with missing or invalid destination
+ if (
+ isinstance(array, (NullObject, str))
+ or (isinstance(array, ArrayObject) and len(array) == 0)
+ or array is None
+ ):
+ page = NullObject()
+ return Destination(title, page, Fit.fit())
+ page, typ, *array = array # type: ignore
+ try:
+ return Destination(title, page, Fit(fit_type=typ, fit_args=array)) # type: ignore
+ except PdfReadError:
+ logger_warning(f"Unknown destination: {title!r} {array}", __name__)
+ if self.strict:
+ raise
+ # create a link to first Page
+ tmp = self.pages[0].indirect_reference
+ indirect_reference = NullObject() if tmp is None else tmp
+ return Destination(title, indirect_reference, Fit.fit())
+
+ def _build_outline_item(self, node: DictionaryObject) -> Optional[Destination]:
+ dest, title, outline_item = None, None, None
+
+ # title required for valid outline
+ # §12.3.3, entries in an outline item dictionary
+ try:
+ title = cast("str", node["/Title"])
+ except KeyError:
+ if self.strict:
+ raise PdfReadError(f"Outline Entry Missing /Title attribute: {node!r}")
+ title = ""
+
+ if "/A" in node:
+ # Action, PDF 1.7 and PDF 2.0 §12.6 (only type GoTo supported)
+ action = cast(DictionaryObject, node["/A"])
+ action_type = cast(NameObject, action[GoToActionArguments.S])
+ if action_type == "/GoTo":
+ if GoToActionArguments.D in action:
+ dest = action[GoToActionArguments.D]
+ elif self.strict:
+ raise PdfReadError(f"Outline Action Missing /D attribute: {node!r}")
+ elif "/Dest" in node:
+ # Destination, PDF 1.7 and PDF 2.0 §12.3.2
+ dest = node["/Dest"]
+ # if array was referenced in another object, will be a dict w/ key "/D"
+ if isinstance(dest, DictionaryObject) and "/D" in dest:
+ dest = dest["/D"]
+
+ if isinstance(dest, ArrayObject):
+ outline_item = self._build_destination(title, dest)
+ elif isinstance(dest, str):
+ # named destination, addresses NameObject Issue #193
+ # TODO: Keep named destination instead of replacing it?
+ try:
+ outline_item = self._build_destination(
+ title, self._named_destinations[dest].dest_array
+ )
+ except KeyError:
+ # named destination not found in Name Dict
+ outline_item = self._build_destination(title, None)
+ elif dest is None:
+ # outline item not required to have destination or action
+ # PDFv1.7 Table 153
+ outline_item = self._build_destination(title, dest)
+ else:
+ if self.strict:
+ raise PdfReadError(f"Unexpected destination {dest!r}")
+ logger_warning(
+ f"Removed unexpected destination {dest!r} from destination",
+ __name__,
+ )
+ outline_item = self._build_destination(title, None)
+
+ # if outline item created, add color, format, and child count if present
+ if outline_item:
+ if "/C" in node:
+ # Color of outline item font in (R, G, B) with values ranging 0.0-1.0
+ outline_item[NameObject("/C")] = ArrayObject(FloatObject(c) for c in node["/C"]) # type: ignore
+ if "/F" in node:
+ # specifies style characteristics bold and/or italic
+ # with 1=italic, 2=bold, 3=both
+ outline_item[NameObject("/F")] = node["/F"]
+ if "/Count" in node:
+ # absolute value = num. visible children
+ # with positive = open/unfolded, negative = closed/folded
+ outline_item[NameObject("/Count")] = node["/Count"]
+ # if count is 0 we will consider it as open (to have available is_open)
+ outline_item[NameObject("/%is_open%")] = BooleanObject(
+ node.get("/Count", 0) >= 0
+ )
+ outline_item.node = node
+ try:
+ outline_item.indirect_reference = node.indirect_reference
+ except AttributeError:
+ pass
+ return outline_item
+
+ @property
+ def pages(self) -> list[PageObject]:
+ """
+ Property that emulates a list of :class:`PageObject`.
+ This property allows to get a page or a range of pages.
+
+ Note:
+ For PdfWriter only: Provides the capability to remove a page/range of
+ page from the list (using the del operator). Remember: Only the page
+ entry is removed, as the objects beneath can be used elsewhere. A
+ solution to completely remove them - if they are not used anywhere - is
+ to write to a buffer/temporary file and then load it into a new
+ PdfWriter.
+
+ """
+ return _VirtualList(self.get_num_pages, self.get_page) # type: ignore
+
+ @property
+ def page_labels(self) -> list[str]:
+ """
+ A list of labels for the pages in this document.
+
+ This property is read-only. The labels are in the order that the pages
+ appear in the document.
+ """
+ return [page_index2page_label(self, i) for i in range(len(self.pages))]
+
+ @property
+ def page_layout(self) -> Optional[str]:
+ """
+ Get the page layout currently being used.
+
+ .. list-table:: Valid ``layout`` values
+ :widths: 50 200
+
+ * - /NoLayout
+ - Layout explicitly not specified
+ * - /SinglePage
+ - Show one page at a time
+ * - /OneColumn
+ - Show one column at a time
+ * - /TwoColumnLeft
+ - Show pages in two columns, odd-numbered pages on the left
+ * - /TwoColumnRight
+ - Show pages in two columns, odd-numbered pages on the right
+ * - /TwoPageLeft
+ - Show two pages at a time, odd-numbered pages on the left
+ * - /TwoPageRight
+ - Show two pages at a time, odd-numbered pages on the right
+ """
+ try:
+ return cast(NameObject, self.root_object[CD.PAGE_LAYOUT])
+ except KeyError:
+ return None
+
+ @property
+ def page_mode(self) -> Optional[PagemodeType]:
+ """
+ Get the page mode currently being used.
+
+ .. list-table:: Valid ``mode`` values
+ :widths: 50 200
+
+ * - /UseNone
+ - Do not show outline or thumbnails panels
+ * - /UseOutlines
+ - Show outline (aka bookmarks) panel
+ * - /UseThumbs
+ - Show page thumbnails panel
+ * - /FullScreen
+ - Fullscreen view
+ * - /UseOC
+ - Show Optional Content Group (OCG) panel
+ * - /UseAttachments
+ - Show attachments panel
+ """
+ try:
+ return self.root_object["/PageMode"] # type: ignore
+ except KeyError:
+ return None
+
+ def _flatten(
+ self,
+ list_only: bool = False,
+ pages: Union[None, DictionaryObject, PageObject] = None,
+ inherit: Optional[dict[str, Any]] = None,
+ indirect_reference: Optional[IndirectObject] = None,
+ ) -> None:
+ """
+ Process the document pages to ease searching.
+
+ Attributes of a page may inherit from ancestor nodes
+ in the page tree. Flattening means moving
+ any inheritance data into descendant nodes,
+ effectively removing the inheritance dependency.
+
+ Note: It is distinct from another use of "flattening" applied to PDFs.
+ Flattening a PDF also means combining all the contents into one single layer
+ and making the file less editable.
+
+ Args:
+ list_only: Will only list the pages within _flatten_pages.
+ pages:
+ inherit:
+ indirect_reference: Used recursively to flatten the /Pages object.
+
+ """
+ inheritable_page_attributes = (
+ NameObject(PG.RESOURCES),
+ NameObject(PG.MEDIABOX),
+ NameObject(PG.CROPBOX),
+ NameObject(PG.ROTATE),
+ )
+ if inherit is None:
+ inherit = {}
+ if pages is None:
+ # Fix issue 327: set flattened_pages attribute only for
+ # decrypted file
+ catalog = self.root_object
+ pages = catalog.get("/Pages").get_object() # type: ignore
+ if not isinstance(pages, DictionaryObject):
+ raise PdfReadError("Invalid object in /Pages")
+ self.flattened_pages = []
+
+ if PagesAttributes.TYPE in pages:
+ t = cast(str, pages[PagesAttributes.TYPE])
+ # if the page tree node has no /Type, consider as a page if /Kids is also missing
+ elif PagesAttributes.KIDS not in pages:
+ t = "/Page"
+ else:
+ t = "/Pages"
+
+ if t == "/Pages":
+ for attr in inheritable_page_attributes:
+ if attr in pages:
+ inherit[attr] = pages[attr]
+ pages_reference = getattr(pages, "indirect_reference", object())
+ for page in cast(ArrayObject, pages[PagesAttributes.KIDS]):
+ if getattr(page, "indirect_reference", object()) == pages_reference:
+ raise PdfReadError("Detected cyclic page references.")
+
+ addt = {}
+ if isinstance(page, IndirectObject):
+ addt["indirect_reference"] = page
+ obj = page.get_object()
+ if obj:
+ # damaged file may have invalid child in /Pages
+ try:
+ self._flatten(list_only, obj, inherit, **addt)
+ except RecursionError:
+ raise PdfReadError(
+ "Maximum recursion depth reached during page flattening."
+ )
+ elif t == "/Page":
+ for attr_in, value in inherit.items():
+ # if the page has its own value, it does not inherit the
+ # parent's value
+ if attr_in not in pages:
+ pages[attr_in] = value
+ page_obj = PageObject(self, indirect_reference)
+ if not list_only:
+ page_obj.update(pages)
+
+ # TODO: Could flattened_pages be None at this point?
+ self.flattened_pages.append(page_obj) # type: ignore
+
+ def remove_page(
+ self,
+ page: Union[int, PageObject, IndirectObject],
+ clean: bool = False,
+ ) -> None:
+ """
+ Remove page from pages list.
+
+ Args:
+ page:
+ * :class:`int`: Page number to be removed.
+ * :class:`~pypdf._page.PageObject`: page to be removed. If the page appears many times
+ only the first one will be removed.
+ * :class:`~pypdf.generic.IndirectObject`: Reference to page to be removed.
+
+ clean: replace PageObject with NullObject to prevent annotations
+ or destinations to reference a detached page.
+
+ """
+ if self.flattened_pages is None:
+ self._flatten(self._readonly)
+ assert self.flattened_pages is not None
+ if isinstance(page, IndirectObject):
+ p = page.get_object()
+ if not isinstance(p, PageObject):
+ logger_warning("IndirectObject is not referencing a page", __name__)
+ return
+ page = p
+
+ if not isinstance(page, int):
+ try:
+ page = self.flattened_pages.index(page)
+ except ValueError:
+ logger_warning("Cannot find page in pages", __name__)
+ return
+ if not (0 <= page < len(self.flattened_pages)):
+ logger_warning("Page number is out of range", __name__)
+ return
+
+ ind = self.pages[page].indirect_reference
+ del self.pages[page]
+ if clean and ind is not None:
+ self._replace_object(ind, NullObject())
+
+ def _get_indirect_object(self, num: int, gen: int) -> Optional[PdfObject]:
+ """
+ Used to ease development.
+
+ This is equivalent to generic.IndirectObject(num,gen,self).get_object()
+
+ Args:
+ num: The object number of the indirect object.
+ gen: The generation number of the indirect object.
+
+ Returns:
+ A PdfObject
+
+ """
+ return IndirectObject(num, gen, self).get_object()
+
+ def decode_permissions(
+ self, permissions_code: int
+ ) -> dict[str, bool]: # pragma: no cover
+ """Take the permissions as an integer, return the allowed access."""
+ deprecation_with_replacement(
+ old_name="decode_permissions",
+ new_name="user_access_permissions",
+ removed_in="5.0.0",
+ )
+
+ permissions_mapping = {
+ "print": UserAccessPermissions.PRINT,
+ "modify": UserAccessPermissions.MODIFY,
+ "copy": UserAccessPermissions.EXTRACT,
+ "annotations": UserAccessPermissions.ADD_OR_MODIFY,
+ "forms": UserAccessPermissions.FILL_FORM_FIELDS,
+ # Do not fix typo, as part of official, but deprecated API.
+ "accessability": UserAccessPermissions.EXTRACT_TEXT_AND_GRAPHICS,
+ "assemble": UserAccessPermissions.ASSEMBLE_DOC,
+ "print_high_quality": UserAccessPermissions.PRINT_TO_REPRESENTATION,
+ }
+
+ return {
+ key: permissions_code & flag != 0
+ for key, flag in permissions_mapping.items()
+ }
+
+ @property
+ def user_access_permissions(self) -> Optional[UserAccessPermissions]:
+ """Get the user access permissions for encrypted documents. Returns None if not encrypted."""
+ if self._encryption is None:
+ return None
+ return UserAccessPermissions(self._encryption.P)
+
+ @property
+ @abstractmethod
+ def is_encrypted(self) -> bool:
+ """
+ Read-only boolean property showing whether this PDF file is encrypted.
+
+ Note that this property, if true, will remain true even after the
+ :meth:`decrypt()` method is called.
+ """
+ ... # pragma: no cover
+
+ @property
+ def xfa(self) -> Optional[dict[str, Any]]:
+ tree: Optional[TreeObject] = None
+ retval: dict[str, Any] = {}
+ catalog = self.root_object
+
+ if "/AcroForm" not in catalog or not catalog["/AcroForm"]:
+ return None
+
+ tree = cast(TreeObject, catalog["/AcroForm"])
+
+ if "/XFA" in tree:
+ fields = cast(ArrayObject, tree["/XFA"])
+ i = iter(fields)
+ for f in i:
+ tag = f
+ f = next(i)
+ if isinstance(f, IndirectObject):
+ field = cast(Optional[EncodedStreamObject], f.get_object())
+ if field:
+ es = zlib.decompress(field._data)
+ retval[tag] = es
+ return retval
+
+ @property
+ def attachments(self) -> Mapping[str, list[bytes]]:
+ """Mapping of attachment filenames to their content."""
+ return LazyDict(
+ {
+ name: (self._get_attachment_list, name)
+ for name in self._list_attachments()
+ }
+ )
+
+ @property
+ def attachment_list(self) -> Generator[EmbeddedFile, None, None]:
+ """Iterable of attachment objects."""
+ yield from EmbeddedFile._load(self.root_object)
+
+ def _list_attachments(self) -> list[str]:
+ """
+ Retrieves the list of filenames of file attachments.
+
+ Returns:
+ list of filenames
+
+ """
+ names = []
+ for entry in self.attachment_list:
+ names.append(entry.name)
+ if (name := entry.alternative_name) != entry.name and name:
+ names.append(name)
+ return names
+
+ def _get_attachment_list(self, name: str) -> list[bytes]:
+ out = self._get_attachments(name)[name]
+ if isinstance(out, list):
+ return out
+ return [out]
+
+ def _get_attachments(
+ self, filename: Optional[str] = None
+ ) -> dict[str, Union[bytes, list[bytes]]]:
+ """
+ Retrieves all or selected file attachments of the PDF as a dictionary of file names
+ and the file data as a bytestring.
+
+ Args:
+ filename: If filename is None, then a dictionary of all attachments
+ will be returned, where the key is the filename and the value
+ is the content. Otherwise, a dictionary with just a single key
+ - the filename - and its content will be returned.
+
+ Returns:
+ dictionary of filename -> Union[bytestring or List[ByteString]]
+ If the filename exists multiple times a list of the different versions will be provided.
+
+ """
+ attachments: dict[str, Union[bytes, list[bytes]]] = {}
+ for entry in self.attachment_list:
+ names = set()
+ alternative_name = entry.alternative_name
+ if filename is not None:
+ if filename in {entry.name, alternative_name}:
+ name = entry.name if filename == entry.name else alternative_name
+ names.add(name)
+ else:
+ continue
+ else:
+ names = {entry.name, alternative_name}
+
+ for name in names:
+ if name is None:
+ continue
+ if name in attachments:
+ if not isinstance(attachments[name], list):
+ attachments[name] = [attachments[name]] # type:ignore
+ attachments[name].append(entry.content) # type:ignore
+ else:
+ attachments[name] = entry.content
+ return attachments
+
+ @abstractmethod
+ def _repr_mimebundle_(
+ self,
+ include: Union[None, Iterable[str]] = None,
+ exclude: Union[None, Iterable[str]] = None,
+ ) -> dict[str, Any]:
+ """
+ Integration into Jupyter Notebooks.
+
+ This method returns a dictionary that maps a mime-type to its
+ representation.
+
+ .. seealso::
+
+ https://ipython.readthedocs.io/en/stable/config/integrating.html
+ """
+ ... # pragma: no cover
+
+
+class LazyDict(Mapping[Any, Any]):
+ def __init__(self, *args: Any, **kwargs: Any) -> None:
+ self._raw_dict = dict(*args, **kwargs)
+
+ def __getitem__(self, key: str) -> Any:
+ func, arg = self._raw_dict.__getitem__(key)
+ return func(arg)
+
+ def __iter__(self) -> Iterator[Any]:
+ return iter(self._raw_dict)
+
+ def __len__(self) -> int:
+ return len(self._raw_dict)
+
+ def __str__(self) -> str:
+ return f"LazyDict(keys={list(self.keys())})"
diff --git a/venv/lib/python3.12/site-packages/pypdf/_encryption.py b/venv/lib/python3.12/site-packages/pypdf/_encryption.py
new file mode 100644
index 0000000..7b2866c
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_encryption.py
@@ -0,0 +1,1178 @@
+# Copyright (c) 2022, exiledkingcc
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+import hashlib
+import secrets
+import struct
+from enum import Enum, IntEnum
+from typing import Any, Optional, Union, cast
+
+from pypdf._crypt_providers import (
+ CryptAES,
+ CryptBase,
+ CryptIdentity,
+ CryptRC4,
+ aes_cbc_decrypt,
+ aes_cbc_encrypt,
+ aes_ecb_decrypt,
+ aes_ecb_encrypt,
+ rc4_decrypt,
+ rc4_encrypt,
+)
+
+from ._utils import logger_warning
+from .generic import (
+ ArrayObject,
+ ByteStringObject,
+ DictionaryObject,
+ NameObject,
+ NumberObject,
+ PdfObject,
+ StreamObject,
+ TextStringObject,
+ create_string_object,
+)
+
+
+class CryptFilter:
+ def __init__(
+ self,
+ stm_crypt: CryptBase,
+ str_crypt: CryptBase,
+ ef_crypt: CryptBase,
+ ) -> None:
+ self.stm_crypt = stm_crypt
+ self.str_crypt = str_crypt
+ self.ef_crypt = ef_crypt
+
+ def encrypt_object(self, obj: PdfObject) -> PdfObject:
+ if isinstance(obj, ByteStringObject):
+ data = self.str_crypt.encrypt(obj.original_bytes)
+ obj = ByteStringObject(data)
+ elif isinstance(obj, TextStringObject):
+ data = self.str_crypt.encrypt(obj.get_encoded_bytes())
+ obj = ByteStringObject(data)
+ elif isinstance(obj, StreamObject):
+ obj2 = StreamObject()
+ obj2.update(obj)
+ obj2.set_data(self.stm_crypt.encrypt(obj._data))
+ for key, value in obj.items(): # Dont forget the Stream dict.
+ obj2[key] = self.encrypt_object(value)
+ obj = obj2
+ elif isinstance(obj, DictionaryObject):
+ obj2 = DictionaryObject() # type: ignore
+ for key, value in obj.items():
+ obj2[key] = self.encrypt_object(value)
+ obj = obj2
+ elif isinstance(obj, ArrayObject):
+ obj = ArrayObject(self.encrypt_object(x) for x in obj)
+ return obj
+
+ def decrypt_object(self, obj: PdfObject) -> PdfObject:
+ if isinstance(obj, (ByteStringObject, TextStringObject)):
+ data = self.str_crypt.decrypt(obj.original_bytes)
+ obj = create_string_object(data)
+ elif isinstance(obj, StreamObject):
+ obj._data = self.stm_crypt.decrypt(obj._data)
+ for key, value in obj.items(): # Dont forget the Stream dict.
+ obj[key] = self.decrypt_object(value)
+ elif isinstance(obj, DictionaryObject):
+ for key, value in obj.items():
+ obj[key] = self.decrypt_object(value)
+ elif isinstance(obj, ArrayObject):
+ for i in range(len(obj)):
+ obj[i] = self.decrypt_object(obj[i])
+ return obj
+
+
+_PADDING = (
+ b"\x28\xbf\x4e\x5e\x4e\x75\x8a\x41\x64\x00\x4e\x56\xff\xfa\x01\x08"
+ b"\x2e\x2e\x00\xb6\xd0\x68\x3e\x80\x2f\x0c\xa9\xfe\x64\x53\x69\x7a"
+)
+
+
+def _padding(data: bytes) -> bytes:
+ return (data + _PADDING)[:32]
+
+
+class AlgV4:
+ @staticmethod
+ def compute_key(
+ password: bytes,
+ rev: int,
+ key_size: int,
+ o_entry: bytes,
+ P: int,
+ id1_entry: bytes,
+ metadata_encrypted: bool,
+ ) -> bytes:
+ """
+ Algorithm 2: Computing an encryption key.
+
+ a) Pad or truncate the password string to exactly 32 bytes. If the
+ password string is more than 32 bytes long,
+ use only its first 32 bytes; if it is less than 32 bytes long, pad it
+ by appending the required number of
+ additional bytes from the beginning of the following padding string:
+ < 28 BF 4E 5E 4E 75 8A 41 64 00 4E 56 FF FA 01 08
+ 2E 2E 00 B6 D0 68 3E 80 2F 0C A9 FE 64 53 69 7A >
+ That is, if the password string is n bytes long, append
+ the first 32 - n bytes of the padding string to the end
+ of the password string. If the password string is empty
+ (zero-length), meaning there is no user password,
+ substitute the entire padding string in its place.
+
+ b) Initialize the MD5 hash function and pass the result of step (a)
+ as input to this function.
+ c) Pass the value of the encryption dictionary’s O entry to the
+ MD5 hash function. ("Algorithm 3: Computing
+ the encryption dictionary’s O (owner password) value" shows how the
+ O value is computed.)
+ d) Convert the integer value of the P entry to a 32-bit unsigned binary
+ number and pass these bytes to the
+ MD5 hash function, low-order byte first.
+ e) Pass the first element of the file’s file identifier array (the value
+ of the ID entry in the document’s trailer
+ dictionary; see Table 15) to the MD5 hash function.
+ f) (Security handlers of revision 4 or greater) If document metadata is
+ not being encrypted, pass 4 bytes with
+ the value 0xFFFFFFFF to the MD5 hash function.
+ g) Finish the hash.
+ h) (Security handlers of revision 3 or greater) Do the following
+ 50 times: Take the output from the previous
+ MD5 hash and pass the first n bytes of the output as input into a new
+ MD5 hash, where n is the number of
+ bytes of the encryption key as defined by the value of the encryption
+ dictionary’s Length entry.
+ i) Set the encryption key to the first n bytes of the output from the
+ final MD5 hash, where n shall always be 5
+ for security handlers of revision 2 but, for security handlers of
+ revision 3 or greater, shall depend on the
+ value of the encryption dictionary’s Length entry.
+
+ Args:
+ password: The encryption secret as a bytes-string
+ rev: The encryption revision (see PDF standard)
+ key_size: The size of the key in bytes
+ o_entry: The owner entry
+ P: A set of flags specifying which operations shall be permitted
+ when the document is opened with user access. If bit 2 is set to 1,
+ all other bits are ignored and all operations are permitted.
+ If bit 2 is set to 0, permission for operations are based on the
+ values of the remaining flags defined in Table 24.
+ id1_entry:
+ metadata_encrypted: A boolean indicating if the metadata is encrypted.
+
+ Returns:
+ The u_hash digest of length key_size
+
+ """
+ a = _padding(password)
+ u_hash = hashlib.md5(a)
+ u_hash.update(o_entry)
+ u_hash.update(struct.pack("= 4 and not metadata_encrypted:
+ u_hash.update(b"\xff\xff\xff\xff")
+ u_hash_digest = u_hash.digest()
+ length = key_size // 8
+ if rev >= 3:
+ for _ in range(50):
+ u_hash_digest = hashlib.md5(u_hash_digest[:length]).digest()
+ return u_hash_digest[:length]
+
+ @staticmethod
+ def compute_O_value_key(owner_password: bytes, rev: int, key_size: int) -> bytes:
+ """
+ Algorithm 3: Computing the encryption dictionary’s O (owner password) value.
+
+ a) Pad or truncate the owner password string as described in step (a)
+ of "Algorithm 2: Computing an encryption key".
+ If there is no owner password, use the user password instead.
+ b) Initialize the MD5 hash function and pass the result of step (a) as
+ input to this function.
+ c) (Security handlers of revision 3 or greater) Do the following 50 times:
+ Take the output from the previous
+ MD5 hash and pass it as input into a new MD5 hash.
+ d) Create an RC4 encryption key using the first n bytes of the output
+ from the final MD5 hash, where n shall
+ always be 5 for security handlers of revision 2 but, for security
+ handlers of revision 3 or greater, shall
+ depend on the value of the encryption dictionary’s Length entry.
+ e) Pad or truncate the user password string as described in step (a) of
+ "Algorithm 2: Computing an encryption key".
+ f) Encrypt the result of step (e), using an RC4 encryption function with
+ the encryption key obtained in step (d).
+ g) (Security handlers of revision 3 or greater) Do the following 19 times:
+ Take the output from the previous
+ invocation of the RC4 function and pass it as input to a new
+ invocation of the function; use an encryption
+ key generated by taking each byte of the encryption key obtained in
+ step (d) and performing an XOR
+ (exclusive or) operation between that byte and the single-byte value
+ of the iteration counter (from 1 to 19).
+ h) Store the output from the final invocation of the RC4 function as
+ the value of the O entry in the encryption dictionary.
+
+ Args:
+ owner_password:
+ rev: The encryption revision (see PDF standard)
+ key_size: The size of the key in bytes
+
+ Returns:
+ The RC4 key
+
+ """
+ a = _padding(owner_password)
+ o_hash_digest = hashlib.md5(a).digest()
+
+ if rev >= 3:
+ for _ in range(50):
+ o_hash_digest = hashlib.md5(o_hash_digest).digest()
+
+ return o_hash_digest[: key_size // 8]
+
+ @staticmethod
+ def compute_O_value(rc4_key: bytes, user_password: bytes, rev: int) -> bytes:
+ """
+ See :func:`compute_O_value_key`.
+
+ Args:
+ rc4_key:
+ user_password:
+ rev: The encryption revision (see PDF standard)
+
+ Returns:
+ The RC4 encrypted
+
+ """
+ a = _padding(user_password)
+ rc4_enc = rc4_encrypt(rc4_key, a)
+ if rev >= 3:
+ for i in range(1, 20):
+ key = bytes(x ^ i for x in rc4_key)
+ rc4_enc = rc4_encrypt(key, rc4_enc)
+ return rc4_enc
+
+ @staticmethod
+ def compute_U_value(key: bytes, rev: int, id1_entry: bytes) -> bytes:
+ """
+ Algorithm 4: Computing the encryption dictionary’s U (user password) value.
+
+ (Security handlers of revision 2)
+
+ a) Create an encryption key based on the user password string, as
+ described in "Algorithm 2: Computing an encryption key".
+ b) Encrypt the 32-byte padding string shown in step (a) of
+ "Algorithm 2: Computing an encryption key", using an RC4 encryption
+ function with the encryption key from the preceding step.
+ c) Store the result of step (b) as the value of the U entry in the
+ encryption dictionary.
+
+ Args:
+ key:
+ rev: The encryption revision (see PDF standard)
+ id1_entry:
+
+ Returns:
+ The value
+
+ """
+ if rev <= 2:
+ return rc4_encrypt(key, _PADDING)
+
+ """
+ Algorithm 5: Computing the encryption dictionary’s U (user password) value.
+
+ (Security handlers of revision 3 or greater)
+
+ a) Create an encryption key based on the user password string, as
+ described in "Algorithm 2: Computing an encryption key".
+ b) Initialize the MD5 hash function and pass the 32-byte padding string
+ shown in step (a) of "Algorithm 2:
+ Computing an encryption key" as input to this function.
+ c) Pass the first element of the file’s file identifier array (the value
+ of the ID entry in the document’s trailer
+ dictionary; see Table 15) to the hash function and finish the hash.
+ d) Encrypt the 16-byte result of the hash, using an RC4 encryption
+ function with the encryption key from step (a).
+ e) Do the following 19 times: Take the output from the previous
+ invocation of the RC4 function and pass it as input to a new
+ invocation of the function; use an encryption key generated by
+ taking each byte of the original encryption key obtained in
+ step (a) and performing an XOR (exclusive or) operation between that
+ byte and the single-byte value of the iteration counter (from 1 to 19).
+ f) Append 16 bytes of arbitrary padding to the output from the final
+ invocation of the RC4 function and store the 32-byte result as the
+ value of the U entry in the encryption dictionary.
+ """
+ u_hash = hashlib.md5(_PADDING)
+ u_hash.update(id1_entry)
+ rc4_enc = rc4_encrypt(key, u_hash.digest())
+ for i in range(1, 20):
+ rc4_key = bytes(x ^ i for x in key)
+ rc4_enc = rc4_encrypt(rc4_key, rc4_enc)
+ return _padding(rc4_enc)
+
+ @staticmethod
+ def verify_user_password(
+ user_password: bytes,
+ rev: int,
+ key_size: int,
+ o_entry: bytes,
+ u_entry: bytes,
+ P: int,
+ id1_entry: bytes,
+ metadata_encrypted: bool,
+ ) -> bytes:
+ """
+ Algorithm 6: Authenticating the user password.
+
+ a) Perform all but the last step of "Algorithm 4: Computing the
+ encryption dictionary’s U (user password) value (Security handlers of
+ revision 2)" or "Algorithm 5: Computing the encryption dictionary’s U
+ (user password) value (Security handlers of revision 3 or greater)"
+ using the supplied password string.
+ b) If the result of step (a) is equal to the value of the encryption
+ dictionary’s U entry (comparing on the first 16 bytes in the case of
+ security handlers of revision 3 or greater), the password supplied is
+ the correct user password. The key obtained in step (a) (that is, in
+ the first step of "Algorithm 4: Computing the encryption
+ dictionary’s U (user password) value
+ (Security handlers of revision 2)" or
+ "Algorithm 5: Computing the encryption dictionary’s U (user password)
+ value (Security handlers of revision 3 or greater)") shall be used
+ to decrypt the document.
+
+ Args:
+ user_password: The user password as a bytes stream
+ rev: The encryption revision (see PDF standard)
+ key_size: The size of the key in bytes
+ o_entry: The owner entry
+ u_entry: The user entry
+ P: A set of flags specifying which operations shall be permitted
+ when the document is opened with user access. If bit 2 is set to 1,
+ all other bits are ignored and all operations are permitted.
+ If bit 2 is set to 0, permission for operations are based on the
+ values of the remaining flags defined in Table 24.
+ id1_entry:
+ metadata_encrypted: A boolean indicating if the metadata is encrypted.
+
+ Returns:
+ The key
+
+ """
+ key = AlgV4.compute_key(
+ user_password, rev, key_size, o_entry, P, id1_entry, metadata_encrypted
+ )
+ u_value = AlgV4.compute_U_value(key, rev, id1_entry)
+ if rev >= 3:
+ u_value = u_value[:16]
+ u_entry = u_entry[:16]
+ if u_value != u_entry:
+ key = b""
+ return key
+
+ @staticmethod
+ def verify_owner_password(
+ owner_password: bytes,
+ rev: int,
+ key_size: int,
+ o_entry: bytes,
+ u_entry: bytes,
+ P: int,
+ id1_entry: bytes,
+ metadata_encrypted: bool,
+ ) -> bytes:
+ """
+ Algorithm 7: Authenticating the owner password.
+
+ a) Compute an encryption key from the supplied password string, as
+ described in steps (a) to (d) of
+ "Algorithm 3: Computing the encryption dictionary’s O (owner password)
+ value".
+ b) (Security handlers of revision 2 only) Decrypt the value of the
+ encryption dictionary’s O entry, using an RC4
+ encryption function with the encryption key computed in step (a).
+ (Security handlers of revision 3 or greater) Do the following 20 times:
+ Decrypt the value of the encryption dictionary’s O entry (first iteration)
+ or the output from the previous iteration (all subsequent iterations),
+ using an RC4 encryption function with a different encryption key at
+ each iteration. The key shall be generated by taking the original key
+ (obtained in step (a)) and performing an XOR (exclusive or) operation
+ between each byte of the key and the single-byte value of the
+ iteration counter (from 19 to 0).
+ c) The result of step (b) purports to be the user password.
+ Authenticate this user password using
+ "Algorithm 6: Authenticating the user password".
+ If it is correct, the password supplied is the correct owner password.
+
+ Args:
+ owner_password:
+ rev: The encryption revision (see PDF standard)
+ key_size: The size of the key in bytes
+ o_entry: The owner entry
+ u_entry: The user entry
+ P: A set of flags specifying which operations shall be permitted
+ when the document is opened with user access. If bit 2 is set to 1,
+ all other bits are ignored and all operations are permitted.
+ If bit 2 is set to 0, permission for operations are based on the
+ values of the remaining flags defined in Table 24.
+ id1_entry:
+ metadata_encrypted: A boolean indicating if the metadata is encrypted.
+
+ Returns:
+ bytes
+
+ """
+ rc4_key = AlgV4.compute_O_value_key(owner_password, rev, key_size)
+
+ if rev <= 2:
+ user_password = rc4_decrypt(rc4_key, o_entry)
+ else:
+ user_password = o_entry
+ for i in range(19, -1, -1):
+ key = bytes(x ^ i for x in rc4_key)
+ user_password = rc4_decrypt(key, user_password)
+ return AlgV4.verify_user_password(
+ user_password,
+ rev,
+ key_size,
+ o_entry,
+ u_entry,
+ P,
+ id1_entry,
+ metadata_encrypted,
+ )
+
+
+class AlgV5:
+ @staticmethod
+ def verify_owner_password(
+ R: int, password: bytes, o_value: bytes, oe_value: bytes, u_value: bytes
+ ) -> bytes:
+ """
+ Algorithm 3.2a Computing an encryption key.
+
+ To understand the algorithm below, it is necessary to treat the O and U
+ strings in the Encrypt dictionary as made up of three sections.
+ The first 32 bytes are a hash value (explained below). The next 8 bytes
+ are called the Validation Salt. The final 8 bytes are called the Key Salt.
+
+ 1. The password string is generated from Unicode input by processing the
+ input string with the SASLprep (IETF RFC 4013) profile of
+ stringprep (IETF RFC 3454), and then converting to a UTF-8
+ representation.
+ 2. Truncate the UTF-8 representation to 127 bytes if it is longer than
+ 127 bytes.
+ 3. Test the password against the owner key by computing the SHA-256 hash
+ of the UTF-8 password concatenated with the 8 bytes of owner
+ Validation Salt, concatenated with the 48-byte U string. If the
+ 32-byte result matches the first 32 bytes of the O string, this is
+ the owner password.
+ Compute an intermediate owner key by computing the SHA-256 hash of
+ the UTF-8 password concatenated with the 8 bytes of owner Key Salt,
+ concatenated with the 48-byte U string. The 32-byte result is the
+ key used to decrypt the 32-byte OE string using AES-256 in CBC mode
+ with no padding and an initialization vector of zero.
+ The 32-byte result is the file encryption key.
+ 4. Test the password against the user key by computing the SHA-256 hash
+ of the UTF-8 password concatenated with the 8 bytes of user
+ Validation Salt. If the 32 byte result matches the first 32 bytes of
+ the U string, this is the user password.
+ Compute an intermediate user key by computing the SHA-256 hash of the
+ UTF-8 password concatenated with the 8 bytes of user Key Salt.
+ The 32-byte result is the key used to decrypt the 32-byte
+ UE string using AES-256 in CBC mode with no padding and an
+ initialization vector of zero. The 32-byte result is the file
+ encryption key.
+ 5. Decrypt the 16-byte Perms string using AES-256 in ECB mode with an
+ initialization vector of zero and the file encryption key as the key.
+ Verify that bytes 9-11 of the result are the characters ‘a’, ‘d’, ‘b’.
+ Bytes 0-3 of the decrypted Perms entry, treated as a little-endian
+ integer, are the user permissions.
+ They should match the value in the P key.
+
+ Args:
+ R: A number specifying which revision of the standard security
+ handler shall be used to interpret this dictionary
+ password: The owner password
+ o_value: A 32-byte string, based on both the owner and user passwords,
+ that shall be used in computing the encryption key and in
+ determining whether a valid owner password was entered
+ oe_value:
+ u_value: A 32-byte string, based on the user password, that shall be
+ used in determining whether to prompt the user for a password and,
+ if so, whether a valid user or owner password was entered.
+
+ Returns:
+ The key
+
+ """
+ password = password[:127]
+ if (
+ AlgV5.calculate_hash(R, password, o_value[32:40], u_value[:48])
+ != o_value[:32]
+ ):
+ return b""
+ iv = bytes(0 for _ in range(16))
+ tmp_key = AlgV5.calculate_hash(R, password, o_value[40:48], u_value[:48])
+ return aes_cbc_decrypt(tmp_key, iv, oe_value)
+
+ @staticmethod
+ def verify_user_password(
+ R: int, password: bytes, u_value: bytes, ue_value: bytes
+ ) -> bytes:
+ """
+ See :func:`verify_owner_password`.
+
+ Args:
+ R: A number specifying which revision of the standard security
+ handler shall be used to interpret this dictionary
+ password: The user password
+ u_value: A 32-byte string, based on the user password, that shall be
+ used in determining whether to prompt the user for a password
+ and, if so, whether a valid user or owner password was entered.
+ ue_value:
+
+ Returns:
+ bytes
+
+ """
+ password = password[:127]
+ if AlgV5.calculate_hash(R, password, u_value[32:40], b"") != u_value[:32]:
+ return b""
+ iv = bytes(0 for _ in range(16))
+ tmp_key = AlgV5.calculate_hash(R, password, u_value[40:48], b"")
+ return aes_cbc_decrypt(tmp_key, iv, ue_value)
+
+ @staticmethod
+ def calculate_hash(R: int, password: bytes, salt: bytes, udata: bytes) -> bytes:
+ # https://github.com/qpdf/qpdf/blob/main/libqpdf/QPDF_encryption.cc
+ k = hashlib.sha256(password + salt + udata).digest()
+ if R < 6:
+ return k
+ count = 0
+ while True:
+ count += 1
+ k1 = password + k + udata
+ e = aes_cbc_encrypt(k[:16], k[16:32], k1 * 64)
+ hash_fn = (
+ hashlib.sha256,
+ hashlib.sha384,
+ hashlib.sha512,
+ )[sum(e[:16]) % 3]
+ k = hash_fn(e).digest()
+ if count >= 64 and e[-1] <= count - 32:
+ break
+ return k[:32]
+
+ @staticmethod
+ def verify_perms(
+ key: bytes, perms: bytes, p: int, metadata_encrypted: bool
+ ) -> bool:
+ """
+ See :func:`verify_owner_password` and :func:`compute_perms_value`.
+
+ Args:
+ key: The owner password
+ perms:
+ p: A set of flags specifying which operations shall be permitted
+ when the document is opened with user access.
+ If bit 2 is set to 1, all other bits are ignored and all
+ operations are permitted.
+ If bit 2 is set to 0, permission for operations are based on
+ the values of the remaining flags defined in Table 24.
+ metadata_encrypted:
+
+ Returns:
+ A boolean
+
+ """
+ b8 = b"T" if metadata_encrypted else b"F"
+ p1 = struct.pack(" dict[Any, Any]:
+ user_password = user_password[:127]
+ owner_password = owner_password[:127]
+ u_value, ue_value = AlgV5.compute_U_value(R, user_password, key)
+ o_value, oe_value = AlgV5.compute_O_value(R, owner_password, key, u_value)
+ perms = AlgV5.compute_Perms_value(key, p, metadata_encrypted)
+ return {
+ "/U": u_value,
+ "/UE": ue_value,
+ "/O": o_value,
+ "/OE": oe_value,
+ "/Perms": perms,
+ }
+
+ @staticmethod
+ def compute_U_value(R: int, password: bytes, key: bytes) -> tuple[bytes, bytes]:
+ """
+ Algorithm 3.8 Computing the encryption dictionary’s U (user password)
+ and UE (user encryption key) values.
+
+ 1. Generate 16 random bytes of data using a strong random number generator.
+ The first 8 bytes are the User Validation Salt. The second 8 bytes
+ are the User Key Salt. Compute the 32-byte SHA-256 hash of the
+ password concatenated with the User Validation Salt. The 48-byte
+ string consisting of the 32-byte hash followed by the User
+ Validation Salt followed by the User Key Salt is stored as the U key.
+ 2. Compute the 32-byte SHA-256 hash of the password concatenated with
+ the User Key Salt. Using this hash as the key, encrypt the file
+ encryption key using AES-256 in CBC mode with no padding and an
+ initialization vector of zero. The resulting 32-byte string is stored
+ as the UE key.
+
+ Args:
+ R:
+ password:
+ key:
+
+ Returns:
+ A tuple (u-value, ue value)
+
+ """
+ random_bytes = secrets.token_bytes(16)
+ val_salt = random_bytes[:8]
+ key_salt = random_bytes[8:]
+ u_value = AlgV5.calculate_hash(R, password, val_salt, b"") + val_salt + key_salt
+
+ tmp_key = AlgV5.calculate_hash(R, password, key_salt, b"")
+ iv = bytes(0 for _ in range(16))
+ ue_value = aes_cbc_encrypt(tmp_key, iv, key)
+ return u_value, ue_value
+
+ @staticmethod
+ def compute_O_value(
+ R: int, password: bytes, key: bytes, u_value: bytes
+ ) -> tuple[bytes, bytes]:
+ """
+ Algorithm 3.9 Computing the encryption dictionary’s O (owner password)
+ and OE (owner encryption key) values.
+
+ 1. Generate 16 random bytes of data using a strong random number
+ generator. The first 8 bytes are the Owner Validation Salt. The
+ second 8 bytes are the Owner Key Salt. Compute the 32-byte SHA-256
+ hash of the password concatenated with the Owner Validation Salt and
+ then concatenated with the 48-byte U string as generated in
+ Algorithm 3.8. The 48-byte string consisting of the 32-byte hash
+ followed by the Owner Validation Salt followed by the Owner Key Salt
+ is stored as the O key.
+ 2. Compute the 32-byte SHA-256 hash of the password concatenated with
+ the Owner Key Salt and then concatenated with the 48-byte U string as
+ generated in Algorithm 3.8. Using this hash as the key,
+ encrypt the file encryption key using AES-256 in CBC mode with
+ no padding and an initialization vector of zero.
+ The resulting 32-byte string is stored as the OE key.
+
+ Args:
+ R:
+ password:
+ key:
+ u_value: A 32-byte string, based on the user password, that shall be
+ used in determining whether to prompt the user for a password
+ and, if so, whether a valid user or owner password was entered.
+
+ Returns:
+ A tuple (O value, OE value)
+
+ """
+ random_bytes = secrets.token_bytes(16)
+ val_salt = random_bytes[:8]
+ key_salt = random_bytes[8:]
+ o_value = (
+ AlgV5.calculate_hash(R, password, val_salt, u_value) + val_salt + key_salt
+ )
+ tmp_key = AlgV5.calculate_hash(R, password, key_salt, u_value[:48])
+ iv = bytes(0 for _ in range(16))
+ oe_value = aes_cbc_encrypt(tmp_key, iv, key)
+ return o_value, oe_value
+
+ @staticmethod
+ def compute_Perms_value(key: bytes, p: int, metadata_encrypted: bool) -> bytes:
+ """
+ Algorithm 3.10 Computing the encryption dictionary’s Perms
+ (permissions) value.
+
+ 1. Extend the permissions (contents of the P integer) to 64 bits by
+ setting the upper 32 bits to all 1’s.
+ (This allows for future extension without changing the format.)
+ 2. Record the 8 bytes of permission in the bytes 0-7 of the block,
+ low order byte first.
+ 3. Set byte 8 to the ASCII value ' T ' or ' F ' according to the
+ EncryptMetadata Boolean.
+ 4. Set bytes 9-11 to the ASCII characters ' a ', ' d ', ' b '.
+ 5. Set bytes 12-15 to 4 bytes of random data, which will be ignored.
+ 6. Encrypt the 16-byte block using AES-256 in ECB mode with an
+ initialization vector of zero, using the file encryption key as the
+ key. The result (16 bytes) is stored as the Perms string, and checked
+ for validity when the file is opened.
+
+ Args:
+ key:
+ p: A set of flags specifying which operations shall be permitted
+ when the document is opened with user access. If bit 2 is set to 1,
+ all other bits are ignored and all operations are permitted.
+ If bit 2 is set to 0, permission for operations are based on the
+ values of the remaining flags defined in Table 24.
+ metadata_encrypted: A boolean indicating if the metadata is encrypted.
+
+ Returns:
+ The perms value
+
+ """
+ b8 = b"T" if metadata_encrypted else b"F"
+ rr = secrets.token_bytes(4)
+ data = struct.pack(" None:
+ # §7.6.2, entries common to all encryption dictionaries
+ # use same name as keys of encryption dictionaries entries
+ self.V = V
+ self.R = R
+ self.Length = Length # key_size
+ self.P = (P + 0x100000000) % 0x100000000 # maybe P < 0
+ self.EncryptMetadata = EncryptMetadata
+ self.id1_entry = first_id_entry
+ self.StmF = StmF
+ self.StrF = StrF
+ self.EFF = EFF
+ self.values: EncryptionValues = values if values else EncryptionValues()
+
+ self._password_type = PasswordType.NOT_DECRYPTED
+ self._key: Optional[bytes] = None
+
+ def is_decrypted(self) -> bool:
+ return self._password_type != PasswordType.NOT_DECRYPTED
+
+ def encrypt_object(self, obj: PdfObject, idnum: int, generation: int) -> PdfObject:
+ # skip calculate key
+ if not self._is_encryption_object(obj):
+ return obj
+
+ cf = self._make_crypt_filter(idnum, generation)
+ return cf.encrypt_object(obj)
+
+ def decrypt_object(self, obj: PdfObject, idnum: int, generation: int) -> PdfObject:
+ # skip calculate key
+ if not self._is_encryption_object(obj):
+ return obj
+
+ cf = self._make_crypt_filter(idnum, generation)
+ return cf.decrypt_object(obj)
+
+ @staticmethod
+ def _is_encryption_object(obj: PdfObject) -> bool:
+ return isinstance(
+ obj,
+ (
+ ByteStringObject,
+ TextStringObject,
+ StreamObject,
+ ArrayObject,
+ DictionaryObject,
+ ),
+ )
+
+ def _make_crypt_filter(self, idnum: int, generation: int) -> CryptFilter:
+ """
+ Algorithm 1: Encryption of data using the RC4 or AES algorithms.
+
+ a) Obtain the object number and generation number from the object
+ identifier of the string or stream to be encrypted
+ (see 7.3.10, "Indirect Objects"). If the string is a direct object,
+ use the identifier of the indirect object containing it.
+ b) For all strings and streams without crypt filter specifier; treating
+ the object number and generation number as binary integers, extend
+ the original n-byte encryption key to n + 5 bytes by appending the
+ low-order 3 bytes of the object number and the low-order 2 bytes of
+ the generation number in that order, low-order byte first.
+ (n is 5 unless the value of V in the encryption dictionary is greater
+ than 1, in which case n is the value of Length divided by 8.)
+ If using the AES algorithm, extend the encryption key an additional
+ 4 bytes by adding the value “sAlT”, which corresponds to the
+ hexadecimal values 0x73, 0x41, 0x6C, 0x54. (This addition is done for
+ backward compatibility and is not intended to provide additional
+ security.)
+ c) Initialize the MD5 hash function and pass the result of step (b) as
+ input to this function.
+ d) Use the first (n + 5) bytes, up to a maximum of 16, of the output
+ from the MD5 hash as the key for the RC4 or AES symmetric key
+ algorithms, along with the string or stream data to be encrypted.
+ If using the AES algorithm, the Cipher Block Chaining (CBC) mode,
+ which requires an initialization vector, is used. The block size
+ parameter is set to 16 bytes, and the initialization vector is a
+ 16-byte random number that is stored as the first 16 bytes of the
+ encrypted stream or string.
+
+ Algorithm 3.1a Encryption of data using the AES algorithm
+ 1. Use the 32-byte file encryption key for the AES-256 symmetric key
+ algorithm, along with the string or stream data to be encrypted.
+ Use the AES algorithm in Cipher Block Chaining (CBC) mode, which
+ requires an initialization vector. The block size parameter is set to
+ 16 bytes, and the initialization vector is a 16-byte random number
+ that is stored as the first 16 bytes of the encrypted stream or string.
+ The output is the encrypted data to be stored in the PDF file.
+ """
+ pack1 = struct.pack(" CryptBase:
+ if method == "/AESV2":
+ return CryptAES(aes128_key)
+ if method == "/AESV3":
+ return CryptAES(aes256_key)
+ if method == "/Identity":
+ return CryptIdentity()
+
+ return CryptRC4(rc4_key)
+
+ @staticmethod
+ def _encode_password(password: Union[bytes, str]) -> bytes:
+ if isinstance(password, str):
+ try:
+ pwd = password.encode("latin-1")
+ except Exception:
+ pwd = password.encode("utf-8")
+ else:
+ pwd = password
+ return pwd
+
+ def verify(self, password: Union[bytes, str]) -> PasswordType:
+ pwd = self._encode_password(password)
+ key, rc = self.verify_v4(pwd) if self.V <= 4 else self.verify_v5(pwd)
+ if rc != PasswordType.NOT_DECRYPTED:
+ self._password_type = rc
+ self._key = key
+ return rc
+
+ def verify_v4(self, password: bytes) -> tuple[bytes, PasswordType]:
+ # verify owner password first
+ key = AlgV4.verify_owner_password(
+ password,
+ self.R,
+ self.Length,
+ self.values.O,
+ self.values.U,
+ self.P,
+ self.id1_entry,
+ self.EncryptMetadata,
+ )
+ if key:
+ return key, PasswordType.OWNER_PASSWORD
+ key = AlgV4.verify_user_password(
+ password,
+ self.R,
+ self.Length,
+ self.values.O,
+ self.values.U,
+ self.P,
+ self.id1_entry,
+ self.EncryptMetadata,
+ )
+ if key:
+ return key, PasswordType.USER_PASSWORD
+ return b"", PasswordType.NOT_DECRYPTED
+
+ def verify_v5(self, password: bytes) -> tuple[bytes, PasswordType]:
+ # TODO: use SASLprep process
+ # verify owner password first
+ key = AlgV5.verify_owner_password(
+ self.R, password, self.values.O, self.values.OE, self.values.U
+ )
+ rc = PasswordType.OWNER_PASSWORD
+ if not key:
+ key = AlgV5.verify_user_password(
+ self.R, password, self.values.U, self.values.UE
+ )
+ rc = PasswordType.USER_PASSWORD
+ if not key:
+ return b"", PasswordType.NOT_DECRYPTED
+
+ # verify Perms
+ if not AlgV5.verify_perms(key, self.values.Perms, self.P, self.EncryptMetadata):
+ logger_warning("ignore '/Perms' verify failed", __name__)
+ return key, rc
+
+ def write_entry(
+ self, user_password: str, owner_password: Optional[str]
+ ) -> DictionaryObject:
+ user_pwd = self._encode_password(user_password)
+ owner_pwd = self._encode_password(owner_password) if owner_password else None
+ if owner_pwd is None:
+ owner_pwd = user_pwd
+
+ if self.V <= 4:
+ self.compute_values_v4(user_pwd, owner_pwd)
+ else:
+ self._key = secrets.token_bytes(self.Length // 8)
+ values = AlgV5.generate_values(
+ self.R, user_pwd, owner_pwd, self._key, self.P, self.EncryptMetadata
+ )
+ self.values.O = values["/O"]
+ self.values.U = values["/U"]
+ self.values.OE = values["/OE"]
+ self.values.UE = values["/UE"]
+ self.values.Perms = values["/Perms"]
+
+ dict_obj = DictionaryObject()
+ dict_obj[NameObject("/V")] = NumberObject(self.V)
+ dict_obj[NameObject("/R")] = NumberObject(self.R)
+ dict_obj[NameObject("/Length")] = NumberObject(self.Length)
+ dict_obj[NameObject("/P")] = NumberObject(self.P)
+ dict_obj[NameObject("/Filter")] = NameObject("/Standard")
+ # ignore /EncryptMetadata
+
+ dict_obj[NameObject("/O")] = ByteStringObject(self.values.O)
+ dict_obj[NameObject("/U")] = ByteStringObject(self.values.U)
+
+ if self.V >= 4:
+ # TODO: allow different method
+ std_cf = DictionaryObject()
+ std_cf[NameObject("/AuthEvent")] = NameObject("/DocOpen")
+ std_cf[NameObject("/CFM")] = NameObject(self.StmF)
+ std_cf[NameObject("/Length")] = NumberObject(self.Length // 8)
+ cf = DictionaryObject()
+ cf[NameObject("/StdCF")] = std_cf
+ dict_obj[NameObject("/CF")] = cf
+ dict_obj[NameObject("/StmF")] = NameObject("/StdCF")
+ dict_obj[NameObject("/StrF")] = NameObject("/StdCF")
+ # ignore EFF
+ # dict_obj[NameObject("/EFF")] = NameObject("/StdCF")
+
+ if self.V >= 5:
+ dict_obj[NameObject("/OE")] = ByteStringObject(self.values.OE)
+ dict_obj[NameObject("/UE")] = ByteStringObject(self.values.UE)
+ dict_obj[NameObject("/Perms")] = ByteStringObject(self.values.Perms)
+ return dict_obj
+
+ def compute_values_v4(self, user_password: bytes, owner_password: bytes) -> None:
+ rc4_key = AlgV4.compute_O_value_key(owner_password, self.R, self.Length)
+ o_value = AlgV4.compute_O_value(rc4_key, user_password, self.R)
+
+ key = AlgV4.compute_key(
+ user_password,
+ self.R,
+ self.Length,
+ o_value,
+ self.P,
+ self.id1_entry,
+ self.EncryptMetadata,
+ )
+ u_value = AlgV4.compute_U_value(key, self.R, self.id1_entry)
+
+ self._key = key
+ self.values.O = o_value
+ self.values.U = u_value
+
+ @staticmethod
+ def read(encryption_entry: DictionaryObject, first_id_entry: bytes) -> "Encryption":
+ if encryption_entry.get("/Filter") != "/Standard":
+ raise NotImplementedError(
+ "only Standard PDF encryption handler is available"
+ )
+ if "/SubFilter" in encryption_entry:
+ raise NotImplementedError("/SubFilter NOT supported")
+
+ stm_filter = "/V2"
+ str_filter = "/V2"
+ ef_filter = "/V2"
+
+ alg_ver = encryption_entry.get("/V", 0)
+ if alg_ver not in (1, 2, 3, 4, 5):
+ raise NotImplementedError(f"Encryption V={alg_ver} NOT supported")
+ if alg_ver >= 4:
+ filters = encryption_entry["/CF"]
+
+ stm_filter = encryption_entry.get("/StmF", "/Identity")
+ str_filter = encryption_entry.get("/StrF", "/Identity")
+ ef_filter = encryption_entry.get("/EFF", stm_filter)
+
+ if stm_filter != "/Identity":
+ stm_filter = filters[stm_filter]["/CFM"] # type: ignore
+ if str_filter != "/Identity":
+ str_filter = filters[str_filter]["/CFM"] # type: ignore
+ if ef_filter != "/Identity":
+ ef_filter = filters[ef_filter]["/CFM"] # type: ignore
+
+ allowed_methods = ("/Identity", "/V2", "/AESV2", "/AESV3")
+ if stm_filter not in allowed_methods:
+ raise NotImplementedError(f"StmF Method {stm_filter} NOT supported!")
+ if str_filter not in allowed_methods:
+ raise NotImplementedError(f"StrF Method {str_filter} NOT supported!")
+ if ef_filter not in allowed_methods:
+ raise NotImplementedError(f"EFF Method {ef_filter} NOT supported!")
+
+ alg_rev = cast(int, encryption_entry["/R"])
+ perm_flags = cast(int, encryption_entry["/P"])
+ key_bits = encryption_entry.get("/Length", 40)
+ encrypt_metadata = encryption_entry.get("/EncryptMetadata")
+ encrypt_metadata = (
+ encrypt_metadata.value if encrypt_metadata is not None else True
+ )
+ values = EncryptionValues()
+ values.O = cast(ByteStringObject, encryption_entry["/O"]).original_bytes
+ values.U = cast(ByteStringObject, encryption_entry["/U"]).original_bytes
+ values.OE = encryption_entry.get("/OE", ByteStringObject()).original_bytes
+ values.UE = encryption_entry.get("/UE", ByteStringObject()).original_bytes
+ values.Perms = encryption_entry.get("/Perms", ByteStringObject()).original_bytes
+ return Encryption(
+ V=alg_ver,
+ R=alg_rev,
+ Length=key_bits,
+ P=perm_flags,
+ EncryptMetadata=encrypt_metadata,
+ first_id_entry=first_id_entry,
+ values=values,
+ StrF=str_filter,
+ StmF=stm_filter,
+ EFF=ef_filter,
+ entry=encryption_entry, # Dummy entry for the moment; will get removed
+ )
+
+ @staticmethod
+ def make(
+ alg: EncryptAlgorithm, permissions: int, first_id_entry: bytes
+ ) -> "Encryption":
+ alg_ver, alg_rev, key_bits = alg
+
+ stm_filter, str_filter, ef_filter = "/V2", "/V2", "/V2"
+
+ if alg == EncryptAlgorithm.AES_128:
+ stm_filter, str_filter, ef_filter = "/AESV2", "/AESV2", "/AESV2"
+ elif alg in (EncryptAlgorithm.AES_256_R5, EncryptAlgorithm.AES_256):
+ stm_filter, str_filter, ef_filter = "/AESV3", "/AESV3", "/AESV3"
+
+ return Encryption(
+ V=alg_ver,
+ R=alg_rev,
+ Length=key_bits,
+ P=permissions,
+ EncryptMetadata=True,
+ first_id_entry=first_id_entry,
+ values=None,
+ StrF=str_filter,
+ StmF=stm_filter,
+ EFF=ef_filter,
+ entry=DictionaryObject(), # Dummy entry for the moment; will get removed
+ )
diff --git a/venv/lib/python3.12/site-packages/pypdf/_font.py b/venv/lib/python3.12/site-packages/pypdf/_font.py
new file mode 100644
index 0000000..54e05b7
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_font.py
@@ -0,0 +1,327 @@
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from typing import Any, Optional, Union, cast
+
+from pypdf.generic import ArrayObject, DictionaryObject, IndirectObject
+
+from ._cmap import get_encoding
+from ._codecs.adobe_glyphs import adobe_glyphs
+from ._utils import logger_warning
+
+
+@dataclass(frozen=True)
+class FontDescriptor:
+ """
+ Represents the FontDescriptor dictionary as defined in the PDF specification.
+ This contains both descriptive and metric information.
+
+ The defaults are derived from the mean values of the 14 core fonts, rounded
+ to 100.
+ """
+
+ name: str = "Unknown"
+ family: str = "Unknown"
+ weight: str = "Unknown"
+
+ ascent: float = 700.0
+ descent: float = -200.0
+ cap_height: float = 600.0
+ x_height: float = 500.0
+ italic_angle: float = 0.0 # Non-italic
+ flags: int = 32 # Non-serif, non-symbolic, not fixed width
+ bbox: tuple[float, float, float, float] = field(default_factory=lambda: (-100.0, -200.0, 1000.0, 900.0))
+
+ character_widths: dict[str, int] = field(default_factory=lambda: {"default": 500})
+
+ @staticmethod
+ def _parse_font_descriptor(font_kwargs: dict[str, Any], font_descriptor_obj: DictionaryObject) -> dict[str, Any]:
+ font_descriptor_dict: DictionaryObject = (
+ font_descriptor_obj.get_object()
+ if isinstance(font_descriptor_obj, IndirectObject)
+ else font_descriptor_obj
+ )
+ for source_key, target_key in [
+ ("/FontName", "name"),
+ ("/FontFamily", "family"),
+ ("/FontWeight", "weight"),
+ ("/Ascent", "ascent"),
+ ("/Descent", "descent"),
+ ("/CapHeight", "cap_height"),
+ ("/XHeight", "x_height"),
+ ("/ItalicAngle", "italic_angle"),
+ ("/Flags", "flags"),
+ ("/FontBBox", "bbox")
+ ]:
+ if source_key in font_descriptor_dict:
+ font_kwargs[target_key] = font_descriptor_dict[source_key]
+ # Handle missing bbox gracefully - PDFs may have fonts without valid bounding boxes
+ if "bbox" in font_kwargs:
+ bbox_tuple = tuple(map(float, font_kwargs["bbox"]))
+ assert len(bbox_tuple) == 4, bbox_tuple
+ font_kwargs["bbox"] = bbox_tuple
+ return font_kwargs
+
+ @staticmethod
+ def _collect_tt_t1_character_widths(
+ pdf_font_dict: DictionaryObject,
+ char_map: dict[Any, Any],
+ encoding: Union[str, dict[int, str]],
+ current_widths: dict[str, int]
+ ) -> None:
+ """Parses a TrueType or Type1 font's /Widths array from a font dictionary and updates character widths"""
+ widths_array = cast(ArrayObject, pdf_font_dict["/Widths"])
+ first_char = pdf_font_dict.get("/FirstChar", 0)
+ if not isinstance(encoding, str):
+ # This means that encoding is a dict
+ current_widths.update({
+ encoding.get(idx + first_char, chr(idx + first_char)): width
+ for idx, width in enumerate(widths_array)
+ })
+ return
+
+ # We map the character code directly to the character
+ # using the string encoding
+ for idx, width in enumerate(widths_array):
+ # Often "idx == 0" will denote the .notdef character, but we add it anyway
+ char_code = idx + first_char # This is a raw code
+ # Get the "raw" character or byte representation
+ raw_char = bytes([char_code]).decode(encoding, "surrogatepass")
+ # Translate raw_char to the REAL Unicode character using the char_map
+ unicode_char = char_map.get(raw_char)
+ if unicode_char:
+ current_widths[unicode_char] = int(width)
+ else:
+ current_widths[raw_char] = int(width)
+
+ @staticmethod
+ def _collect_cid_character_widths(
+ d_font: DictionaryObject, char_map: dict[Any, Any], current_widths: dict[str, int]
+ ) -> None:
+ """Parses the /W array from a DescendantFont dictionary and updates character widths."""
+ ord_map = {
+ ord(_target): _surrogate
+ for _target, _surrogate in char_map.items()
+ if isinstance(_target, str)
+ }
+ # /W width definitions have two valid formats which can be mixed and matched:
+ # (1) A character start index followed by a list of widths, e.g.
+ # `45 [500 600 700]` applies widths 500, 600, 700 to characters 45-47.
+ # (2) A character start index, a character stop index, and a width, e.g.
+ # `45 65 500` applies width 500 to characters 45-65.
+ skip_count = 0
+ _w = d_font.get("/W", [])
+ for idx, w_entry in enumerate(_w):
+ w_entry = w_entry.get_object()
+ if skip_count:
+ skip_count -= 1
+ continue
+ if not isinstance(w_entry, (int, float)):
+ # We should never get here due to skip_count above. But
+ # sometimes we do.
+ logger_warning(f"Expected numeric value for width, got {w_entry}. Ignoring it.", __name__)
+ continue
+ # check for format (1): `int [int int int int ...]`
+ w_next_entry = _w[idx + 1].get_object()
+ if isinstance(w_next_entry, Sequence):
+ start_idx, width_list = w_entry, w_next_entry
+ current_widths.update(
+ {
+ ord_map[_cidx]: _width
+ for _cidx, _width in zip(
+ range(
+ cast(int, start_idx),
+ cast(int, start_idx) + len(width_list),
+ 1,
+ ),
+ width_list,
+ )
+ if _cidx in ord_map
+ }
+ )
+ skip_count = 1
+ # check for format (2): `int int int`
+ elif isinstance(w_next_entry, (int, float)) and isinstance(
+ _w[idx + 2].get_object(), (int, float)
+ ):
+ start_idx, stop_idx, const_width = (
+ w_entry,
+ w_next_entry,
+ _w[idx + 2].get_object(),
+ )
+ current_widths.update(
+ {
+ ord_map[_cidx]: const_width
+ for _cidx in range(
+ cast(int, start_idx), cast(int, stop_idx + 1), 1
+ )
+ if _cidx in ord_map
+ }
+ )
+ skip_count = 2
+ else:
+ # This handles the case of out of bounds (reaching the end of the width definitions
+ # while expecting more elements).
+ logger_warning(
+ f"Invalid font width definition. Last element: {w_entry}.",
+ __name__
+ )
+
+ @staticmethod
+ def _add_default_width(current_widths: dict[str, int]) -> None:
+ if not current_widths:
+ current_widths["default"] = 500
+ return
+
+ if "default" in current_widths:
+ return
+
+ if " " in current_widths and current_widths[" "] != 0:
+ # Setting default to twice the space width
+ current_widths["default"] = int(2 * current_widths[" "])
+ return
+
+ # Use the average width of existing glyph widths
+ valid_widths = [w for w in current_widths.values() if w > 0]
+ current_widths["default"] = sum(valid_widths) // len(valid_widths) if valid_widths else 500
+
+ @classmethod
+ def from_font_resource(
+ cls,
+ pdf_font_dict: DictionaryObject,
+ encoding: Optional[Union[str, dict[int, str]]] = None,
+ char_map: Optional[dict[Any, Any]] = None
+ ) -> "FontDescriptor":
+ from pypdf._codecs.core_fontmetrics import CORE_FONT_METRICS # noqa: PLC0415
+ # Prioritize information from the PDF font dictionary
+ font_name = pdf_font_dict.get("/BaseFont", "Unknown").removeprefix("/")
+ font_kwargs: dict[str, Any] = {"character_widths": {}}
+
+ # Deal with fonts by type; Type1, TrueType and certain Type3
+ if pdf_font_dict.get("/Subtype") in ("/Type1", "/MMType1", "/TrueType", "/Type3"):
+ if "/Widths" in pdf_font_dict:
+ if not (encoding and char_map):
+ encoding, char_map = get_encoding(pdf_font_dict)
+ cls._collect_tt_t1_character_widths(
+ pdf_font_dict, char_map, encoding, font_kwargs["character_widths"]
+ )
+ elif font_name in CORE_FONT_METRICS:
+ font_descriptor = CORE_FONT_METRICS[font_name]
+ cls._add_default_width(font_descriptor.character_widths)
+
+ return font_descriptor
+
+ if "/FontDescriptor" in pdf_font_dict: # TODO: This does not account for some Type3 fonts;
+ # see tests/test_cmap.py::test_ascii_charset
+ font_descriptor_resource = pdf_font_dict.get("/FontDescriptor", DictionaryObject()).get_object()
+ font_descriptor_obj = cast(DictionaryObject, font_descriptor_resource)
+ if "/MissingWidth" in font_descriptor_obj:
+ font_kwargs["character_widths"]["default"] = font_descriptor_obj["/MissingWidth"].get_object()
+ font_kwargs = cls._parse_font_descriptor(
+ font_kwargs, pdf_font_dict.get("/FontDescriptor", DictionaryObject())
+ )
+ if "default" not in font_kwargs["character_widths"]:
+ cls._add_default_width(font_kwargs["character_widths"])
+
+ return cls(**font_kwargs)
+
+ # Composite font or CID font - CID fonts have a /W array mapping character codes
+ # to widths stashed in /DescendantFonts. No need to test for /DescendantFonts though,
+ # because all other fonts have already been dealt with.
+ if not (encoding and char_map):
+ encoding, char_map = get_encoding(pdf_font_dict)
+ d_font: DictionaryObject
+ for d_font_idx, d_font in enumerate(
+ cast(ArrayObject, pdf_font_dict["/DescendantFonts"])
+ ):
+ d_font = cast(DictionaryObject, d_font.get_object())
+ cast(ArrayObject, pdf_font_dict["/DescendantFonts"])[d_font_idx] = d_font
+ cls._collect_cid_character_widths(
+ d_font, char_map, font_kwargs["character_widths"]
+ )
+ if "/DW" in d_font:
+ font_kwargs["character_widths"]["default"] = d_font["/DW"].get_object()
+ else:
+ cls._add_default_width(font_kwargs["character_widths"])
+ font_kwargs = cls._parse_font_descriptor(
+ font_kwargs, d_font.get("/FontDescriptor", DictionaryObject())
+ )
+
+ return cls(**font_kwargs)
+
+
+@dataclass
+class Font:
+ """
+ A font object for use during text extraction and for producing
+ text appearance streams.
+
+ Attributes:
+ name: Font name, derived from font["/BaseFont"]
+ character_map: The font's character map
+ encoding: Font encoding
+ sub_type: The font type, such as Type1, TrueType, or Type3.
+ font_descriptor: Font metrics, including a mapping of characters to widths
+ character_widths: A mapping of characters to widths
+ space_width: The width of a space, or an approximation
+ interpretable: Default True. If False, the font glyphs cannot
+ be translated to characters, e.g. Type3 fonts that do not define
+ a '/ToUnicode' mapping.
+
+ """
+
+ name: str
+ encoding: Union[str, dict[int, str]]
+ character_map: dict[Any, Any] = field(default_factory=dict)
+ sub_type: str = "Unknown"
+ font_descriptor: FontDescriptor = field(default_factory=FontDescriptor)
+ character_widths: dict[str, int] = field(default_factory=dict)
+ space_width: Union[float, int] = 250
+ interpretable: bool = True
+
+ @classmethod
+ def from_font_resource(
+ cls,
+ pdf_font_dict: DictionaryObject,
+ ) -> "Font":
+ # Can collect base_font, name and encoding directly from font resource
+ name = pdf_font_dict.get("/BaseFont", "Unknown").removeprefix("/")
+ sub_type = pdf_font_dict.get("/Subtype", "Unknown").removeprefix("/")
+ encoding, character_map = get_encoding(pdf_font_dict)
+
+ # Type3 fonts that do not specify a "/ToUnicode" mapping cannot be
+ # reliably converted into character codes unless all named chars
+ # in /CharProcs map to a standard adobe glyph. See §9.10.2 of the
+ # PDF 1.7 standard.
+ interpretable = True
+ if sub_type == "Type3" and "/ToUnicode" not in pdf_font_dict:
+ interpretable = all(
+ cname in adobe_glyphs
+ for cname in pdf_font_dict.get("/CharProcs") or []
+ )
+
+ if interpretable:
+ font_descriptor = FontDescriptor.from_font_resource(pdf_font_dict, encoding, character_map)
+ else:
+ font_descriptor = FontDescriptor() # Save some overhead if font is not interpretable
+ character_widths = font_descriptor.character_widths
+
+ space_width = font_descriptor.character_widths.get(" ")
+ if not space_width or space_width == 0:
+ space_width = font_descriptor.character_widths["default"] // 2
+
+ return cls(
+ name=name,
+ sub_type=sub_type,
+ encoding=encoding,
+ font_descriptor=font_descriptor,
+ character_map=character_map,
+ character_widths=character_widths,
+ space_width=space_width,
+ interpretable=interpretable
+ )
+
+ def text_width(self, text: str = "") -> float:
+ """Sum of character widths specified in PDF font for the supplied text."""
+ return sum(
+ [self.character_widths.get(char, self.character_widths["default"]) for char in text], 0.0
+ )
diff --git a/venv/lib/python3.12/site-packages/pypdf/_page.py b/venv/lib/python3.12/site-packages/pypdf/_page.py
new file mode 100644
index 0000000..732a98a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_page.py
@@ -0,0 +1,2353 @@
+# Copyright (c) 2006, Mathieu Fenniak
+# Copyright (c) 2007, Ashish Kulkarni
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+
+import math
+from collections.abc import Iterable, Iterator, Sequence
+from copy import deepcopy
+from dataclasses import asdict, dataclass
+from decimal import Decimal
+from io import BytesIO
+from pathlib import Path
+from typing import (
+ Any,
+ Callable,
+ Literal,
+ Optional,
+ Union,
+ cast,
+ overload,
+)
+
+from ._font import Font
+from ._protocols import PdfCommonDocProtocol
+from ._text_extraction import (
+ _layout_mode,
+)
+from ._text_extraction._text_extractor import TextExtraction
+from ._utils import (
+ CompressedTransformationMatrix,
+ TransformationMatrixType,
+ _human_readable_bytes,
+ deprecate,
+ logger_warning,
+ matrix_multiply,
+)
+from .constants import _INLINE_IMAGE_KEY_MAPPING, _INLINE_IMAGE_VALUE_MAPPING
+from .constants import AnnotationDictionaryAttributes as ADA
+from .constants import ImageAttributes as IA
+from .constants import PageAttributes as PG
+from .constants import Resources as RES
+from .errors import PageSizeNotDefinedError, PdfReadError
+from .generic import (
+ ArrayObject,
+ ContentStream,
+ DictionaryObject,
+ EncodedStreamObject,
+ FloatObject,
+ IndirectObject,
+ NameObject,
+ NullObject,
+ NumberObject,
+ PdfObject,
+ RectangleObject,
+ StreamObject,
+ is_null_or_none,
+)
+
+try:
+ from PIL.Image import Image
+
+ pil_not_imported = False
+except ImportError:
+ Image = object # type: ignore[assignment,misc,unused-ignore] # TODO: Remove unused-ignore on Python 3.10
+ pil_not_imported = True # error will be raised only when using images
+
+MERGE_CROP_BOX = "cropbox" # pypdf <= 3.4.0 used "trimbox"
+
+
+def _get_rectangle(self: Any, name: str, defaults: Iterable[str]) -> RectangleObject:
+ retval: Union[None, RectangleObject, IndirectObject] = self.get(name)
+ if isinstance(retval, RectangleObject):
+ return retval
+ if is_null_or_none(retval):
+ for d in defaults:
+ retval = self.get(d)
+ if retval is not None:
+ break
+ if isinstance(retval, IndirectObject):
+ retval = self.pdf.get_object(retval)
+ retval = RectangleObject(retval) # type: ignore
+ _set_rectangle(self, name, retval)
+ return retval
+
+
+def _set_rectangle(self: Any, name: str, value: Union[RectangleObject, float]) -> None:
+ self[NameObject(name)] = value
+
+
+def _delete_rectangle(self: Any, name: str) -> None:
+ del self[name]
+
+
+def _create_rectangle_accessor(name: str, fallback: Iterable[str]) -> property:
+ return property(
+ lambda self: _get_rectangle(self, name, fallback),
+ lambda self, value: _set_rectangle(self, name, value),
+ lambda self: _delete_rectangle(self, name),
+ )
+
+
+class Transformation:
+ """
+ Represent a 2D transformation.
+
+ The transformation between two coordinate systems is represented by a 3-by-3
+ transformation matrix with the following form::
+
+ a b 0
+ c d 0
+ e f 1
+
+ Because a transformation matrix has only six elements that can be changed,
+ it is usually specified in PDF as the six-element array [ a b c d e f ].
+
+ Coordinate transformations are expressed as matrix multiplications::
+
+ a b 0
+ [ x′ y′ 1 ] = [ x y 1 ] × c d 0
+ e f 1
+
+
+ Example:
+ >>> from pypdf import PdfWriter, Transformation
+ >>> page = PdfWriter().add_blank_page(800, 600)
+ >>> op = Transformation().scale(sx=2, sy=3).translate(tx=10, ty=20)
+ >>> page.add_transformation(op)
+
+ """
+
+ def __init__(self, ctm: CompressedTransformationMatrix = (1, 0, 0, 1, 0, 0)) -> None:
+ self.ctm = ctm
+
+ @property
+ def matrix(self) -> TransformationMatrixType:
+ """
+ Return the transformation matrix as a tuple of tuples in the form:
+
+ ((a, b, 0), (c, d, 0), (e, f, 1))
+ """
+ return (
+ (self.ctm[0], self.ctm[1], 0),
+ (self.ctm[2], self.ctm[3], 0),
+ (self.ctm[4], self.ctm[5], 1),
+ )
+
+ @staticmethod
+ def compress(matrix: TransformationMatrixType) -> CompressedTransformationMatrix:
+ """
+ Compresses the transformation matrix into a tuple of (a, b, c, d, e, f).
+
+ Args:
+ matrix: The transformation matrix as a tuple of tuples.
+
+ Returns:
+ A tuple representing the transformation matrix as (a, b, c, d, e, f)
+
+ """
+ return (
+ matrix[0][0],
+ matrix[0][1],
+ matrix[1][0],
+ matrix[1][1],
+ matrix[2][0],
+ matrix[2][1],
+ )
+
+ def _to_cm(self) -> str:
+ # Returns the cm operation string for the given transformation matrix
+ return (
+ f"{self.ctm[0]:.4f} {self.ctm[1]:.4f} {self.ctm[2]:.4f} "
+ f"{self.ctm[3]:.4f} {self.ctm[4]:.4f} {self.ctm[5]:.4f} cm"
+ )
+
+ def transform(self, m: "Transformation") -> "Transformation":
+ """
+ Apply one transformation to another.
+
+ Args:
+ m: a Transformation to apply.
+
+ Returns:
+ A new ``Transformation`` instance
+
+ Example:
+ >>> from pypdf import PdfWriter, Transformation
+ >>> height, width = 40, 50
+ >>> page = PdfWriter().add_blank_page(800, 600)
+ >>> op = Transformation((1, 0, 0, -1, 0, height)) # vertical mirror
+ >>> op = Transformation().transform(Transformation((-1, 0, 0, 1, width, 0))) # horizontal mirror
+ >>> page.add_transformation(op)
+
+ """
+ ctm = Transformation.compress(matrix_multiply(self.matrix, m.matrix))
+ return Transformation(ctm)
+
+ def translate(self, tx: float = 0, ty: float = 0) -> "Transformation":
+ """
+ Translate the contents of a page.
+
+ Args:
+ tx: The translation along the x-axis.
+ ty: The translation along the y-axis.
+
+ Returns:
+ A new ``Transformation`` instance
+
+ """
+ m = self.ctm
+ return Transformation(ctm=(m[0], m[1], m[2], m[3], m[4] + tx, m[5] + ty))
+
+ def scale(
+ self, sx: Optional[float] = None, sy: Optional[float] = None
+ ) -> "Transformation":
+ """
+ Scale the contents of a page towards the origin of the coordinate system.
+
+ Typically, that is the lower-left corner of the page. That can be
+ changed by translating the contents / the page boxes.
+
+ Args:
+ sx: The scale factor along the x-axis.
+ sy: The scale factor along the y-axis.
+
+ Returns:
+ A new Transformation instance with the scaled matrix.
+
+ """
+ if sx is None and sy is None:
+ raise ValueError("Either sx or sy must be specified")
+ if sx is None:
+ sx = sy
+ if sy is None:
+ sy = sx
+ assert sx is not None
+ assert sy is not None
+ op: TransformationMatrixType = ((sx, 0, 0), (0, sy, 0), (0, 0, 1))
+ ctm = Transformation.compress(matrix_multiply(self.matrix, op))
+ return Transformation(ctm)
+
+ def rotate(self, rotation: float) -> "Transformation":
+ """
+ Rotate the contents of a page.
+
+ Args:
+ rotation: The angle of rotation in degrees.
+
+ Returns:
+ A new ``Transformation`` instance with the rotated matrix.
+
+ """
+ rotation = math.radians(rotation)
+ op: TransformationMatrixType = (
+ (math.cos(rotation), math.sin(rotation), 0),
+ (-math.sin(rotation), math.cos(rotation), 0),
+ (0, 0, 1),
+ )
+ ctm = Transformation.compress(matrix_multiply(self.matrix, op))
+ return Transformation(ctm)
+
+ def __repr__(self) -> str:
+ return f"Transformation(ctm={self.ctm})"
+
+ @overload
+ def apply_on(self, pt: list[float], as_object: bool = False) -> list[float]:
+ ...
+
+ @overload
+ def apply_on(
+ self, pt: tuple[float, float], as_object: bool = False
+ ) -> tuple[float, float]:
+ ...
+
+ def apply_on(
+ self,
+ pt: Union[tuple[float, float], list[float]],
+ as_object: bool = False,
+ ) -> Union[tuple[float, float], list[float]]:
+ """
+ Apply the transformation matrix on the given point.
+
+ Args:
+ pt: A tuple or list representing the point in the form (x, y).
+ as_object: If True, return items as FloatObject, otherwise as plain floats.
+
+ Returns:
+ A tuple or list representing the transformed point in the form (x', y')
+
+ """
+ typ = FloatObject if as_object else float
+ pt1 = (
+ typ(float(pt[0]) * self.ctm[0] + float(pt[1]) * self.ctm[2] + self.ctm[4]),
+ typ(float(pt[0]) * self.ctm[1] + float(pt[1]) * self.ctm[3] + self.ctm[5]),
+ )
+ return list(pt1) if isinstance(pt, list) else pt1
+
+
+@dataclass
+class ImageFile:
+ """
+ Image within the PDF file. *This object is not designed to be built.*
+
+ This object should not be modified except using :func:`ImageFile.replace` to replace the image with a new one.
+ """
+
+ name: str = ""
+ """
+ Filename as identified within the PDF file.
+ """
+
+ data: bytes = b""
+ """
+ Data as bytes.
+ """
+
+ image: Optional[Image] = None
+ """
+ Data as PIL image.
+ """
+
+ indirect_reference: Optional[IndirectObject] = None
+ """
+ Reference to the object storing the stream.
+ """
+
+ def replace(self, new_image: Image, **kwargs: Any) -> None:
+ """
+ Replace the image with a new PIL image.
+
+ Args:
+ new_image (PIL.Image.Image): The new PIL image to replace the existing image.
+ **kwargs: Additional keyword arguments to pass to `Image.save()`.
+
+ Raises:
+ TypeError: If the image is inline or in a PdfReader.
+ TypeError: If the image does not belong to a PdfWriter.
+ TypeError: If `new_image` is not a PIL Image.
+
+ Note:
+ This method replaces the existing image with a new image.
+ It is not allowed for inline images or images within a PdfReader.
+ The `kwargs` parameter allows passing additional parameters
+ to `Image.save()`, such as quality.
+
+ """
+ if pil_not_imported:
+ raise ImportError(
+ "pillow is required to do image extraction. "
+ "It can be installed via 'pip install pypdf[image]'"
+ )
+
+ from ._reader import PdfReader # noqa: PLC0415
+
+ # to prevent circular import
+ from ._xobj_image_helpers import _xobj_to_image # noqa: PLC0415
+ from .generic import DictionaryObject, PdfObject # noqa: PLC0415
+
+ if self.indirect_reference is None:
+ raise TypeError("Cannot update an inline image.")
+ if not hasattr(self.indirect_reference.pdf, "_id_translated"):
+ raise TypeError("Cannot update an image not belonging to a PdfWriter.")
+ if not isinstance(new_image, Image):
+ raise TypeError("new_image shall be a PIL Image")
+ b = BytesIO()
+ new_image.save(b, "PDF", **kwargs)
+ reader = PdfReader(b)
+ page_image = reader.pages[0].images[0]
+ assert page_image.indirect_reference is not None
+ self.indirect_reference.pdf._objects[self.indirect_reference.idnum - 1] = (
+ page_image.indirect_reference.get_object()
+ )
+ cast(
+ PdfObject, self.indirect_reference.get_object()
+ ).indirect_reference = self.indirect_reference
+ # change the object attributes
+ extension, byte_stream, img = _xobj_to_image(
+ cast(DictionaryObject, self.indirect_reference.get_object()),
+ pillow_parameters=kwargs,
+ )
+ assert extension is not None
+ self.name = self.name[: self.name.rfind(".")] + extension
+ self.data = byte_stream
+ self.image = img
+
+ def __str__(self) -> str:
+ return f"{self.__class__.__name__}(name={self.name}, data: {_human_readable_bytes(len(self.data))})"
+
+ def __repr__(self) -> str:
+ return self.__str__()[:-1] + f", hash: {hash(self.data)})"
+
+
+class VirtualListImages(Sequence[ImageFile]):
+ """
+ Provides access to images referenced within a page.
+ Only one copy will be returned if the usage is used on the same page multiple times.
+ See :func:`PageObject.images` for more details.
+ """
+
+ def __init__(
+ self,
+ ids_function: Callable[[], list[Union[str, list[str]]]],
+ get_function: Callable[[Union[str, list[str], tuple[str]]], ImageFile],
+ ) -> None:
+ self.ids_function = ids_function
+ self.get_function = get_function
+ self.current = -1
+
+ def __len__(self) -> int:
+ return len(self.ids_function())
+
+ def keys(self) -> list[Union[str, list[str]]]:
+ return self.ids_function()
+
+ def items(self) -> list[tuple[Union[str, list[str]], ImageFile]]:
+ return [(x, self[x]) for x in self.ids_function()]
+
+ @overload
+ def __getitem__(self, index: Union[int, str, list[str]]) -> ImageFile:
+ ...
+
+ @overload
+ def __getitem__(self, index: slice) -> Sequence[ImageFile]:
+ ...
+
+ def __getitem__(
+ self, index: Union[int, slice, str, list[str], tuple[str]]
+ ) -> Union[ImageFile, Sequence[ImageFile]]:
+ lst = self.ids_function()
+ if isinstance(index, slice):
+ indices = range(*index.indices(len(self)))
+ lst = [lst[x] for x in indices]
+ cls = type(self)
+ return cls((lambda: lst), self.get_function)
+ if isinstance(index, (str, list, tuple)):
+ return self.get_function(index)
+ if not isinstance(index, int):
+ raise TypeError("Invalid sequence indices type")
+ len_self = len(lst)
+ if index < 0:
+ # support negative indexes
+ index += len_self
+ if not (0 <= index < len_self):
+ raise IndexError("Sequence index out of range")
+ return self.get_function(lst[index])
+
+ def __iter__(self) -> Iterator[ImageFile]:
+ for i in range(len(self)):
+ yield self[i]
+
+ def __str__(self) -> str:
+ p = [f"Image_{i}={n}" for i, n in enumerate(self.ids_function())]
+ return f"[{', '.join(p)}]"
+
+
+class PageObject(DictionaryObject):
+ """
+ PageObject represents a single page within a PDF file.
+
+ Typically these objects will be created by accessing the
+ :attr:`pages` property of the
+ :class:`PdfReader` class, but it is
+ also possible to create an empty page with the
+ :meth:`create_blank_page()` static method.
+
+ Args:
+ pdf: PDF file the page belongs to.
+ indirect_reference: Stores the original indirect reference to
+ this object in its source PDF
+
+ """
+
+ original_page: "PageObject" # very local use in writer when appending
+
+ def __init__(
+ self,
+ pdf: Optional[PdfCommonDocProtocol] = None,
+ indirect_reference: Optional[IndirectObject] = None,
+ ) -> None:
+ DictionaryObject.__init__(self)
+ self.pdf = pdf
+ self.inline_images: Optional[dict[str, ImageFile]] = None
+ self.indirect_reference = indirect_reference
+ if not is_null_or_none(indirect_reference):
+ assert indirect_reference is not None, "mypy"
+ self.update(cast(DictionaryObject, indirect_reference.get_object()))
+ self._font_width_maps: dict[str, tuple[dict[str, float], str, float]] = {}
+
+ def hash_bin(self) -> int:
+ """
+ Used to detect modified object.
+
+ Note: this function is overloaded to return the same results
+ as a DictionaryObject.
+
+ Returns:
+ Hash considering type and value.
+
+ """
+ return hash(
+ (DictionaryObject, tuple(((k, v.hash_bin()) for k, v in self.items())))
+ )
+
+ def hash_value_data(self) -> bytes:
+ data = super().hash_value_data()
+ data += f"{id(self)}".encode()
+ return data
+
+ @property
+ def user_unit(self) -> float:
+ """
+ A read-only positive number giving the size of user space units.
+
+ It is in multiples of 1/72 inch. Hence a value of 1 means a user
+ space unit is 1/72 inch, and a value of 3 means that a user
+ space unit is 3/72 inch.
+ """
+ return self.get(PG.USER_UNIT, 1)
+
+ @staticmethod
+ def create_blank_page(
+ pdf: Optional[PdfCommonDocProtocol] = None,
+ width: Union[float, Decimal, None] = None,
+ height: Union[float, Decimal, None] = None,
+ ) -> "PageObject":
+ """
+ Return a new blank page.
+
+ If ``width`` or ``height`` is ``None``, try to get the page size
+ from the last page of *pdf*.
+
+ Args:
+ pdf: PDF file the page is within.
+ width: The width of the new page expressed in default user
+ space units.
+ height: The height of the new page expressed in default user
+ space units.
+
+ Returns:
+ The new blank page
+
+ Raises:
+ PageSizeNotDefinedError: if ``pdf`` is ``None`` or contains
+ no page
+
+ """
+ page = PageObject(pdf)
+
+ # Creates a new page (cf PDF Reference §7.7.3.3)
+ page.__setitem__(NameObject(PG.TYPE), NameObject("/Page"))
+ page.__setitem__(NameObject(PG.PARENT), NullObject())
+ page.__setitem__(NameObject(PG.RESOURCES), DictionaryObject())
+ if width is None or height is None:
+ if pdf is not None and len(pdf.pages) > 0:
+ lastpage = pdf.pages[len(pdf.pages) - 1]
+ width = lastpage.mediabox.width
+ height = lastpage.mediabox.height
+ else:
+ raise PageSizeNotDefinedError
+ page.__setitem__(
+ NameObject(PG.MEDIABOX), RectangleObject((0, 0, width, height)) # type: ignore
+ )
+
+ return page
+
+ def _get_ids_image(
+ self,
+ obj: Optional[DictionaryObject] = None,
+ ancest: Optional[list[str]] = None,
+ call_stack: Optional[list[Any]] = None,
+ ) -> list[Union[str, list[str]]]:
+ if call_stack is None:
+ call_stack = []
+ _i = getattr(obj, "indirect_reference", None)
+ if _i in call_stack:
+ return []
+ call_stack.append(_i)
+ if self.inline_images is None:
+ self.inline_images = self._get_inline_images()
+ if obj is None:
+ obj = self
+ if ancest is None:
+ ancest = []
+ lst: list[Union[str, list[str]]] = []
+ if (
+ PG.RESOURCES not in obj or
+ is_null_or_none(resources := obj[PG.RESOURCES]) or
+ RES.XOBJECT not in cast(DictionaryObject, resources)
+ ):
+ return [] if self.inline_images is None else list(self.inline_images.keys())
+
+ x_object = resources[RES.XOBJECT].get_object() # type: ignore
+ for o in x_object:
+ if not isinstance(x_object[o], StreamObject):
+ continue
+ if x_object[o][IA.SUBTYPE] == "/Image":
+ lst.append(o if len(ancest) == 0 else [*ancest, o])
+ else: # is a form with possible images inside
+ lst.extend(self._get_ids_image(x_object[o], [*ancest, o], call_stack))
+ assert self.inline_images is not None
+ lst.extend(list(self.inline_images.keys()))
+ return lst
+
+ def _get_image(
+ self,
+ id: Union[str, list[str], tuple[str]],
+ obj: Optional[DictionaryObject] = None,
+ ) -> ImageFile:
+ if obj is None:
+ obj = cast(DictionaryObject, self)
+ if isinstance(id, tuple):
+ id = list(id)
+ if isinstance(id, list) and len(id) == 1:
+ id = id[0]
+ try:
+ xobjs = cast(
+ DictionaryObject, cast(DictionaryObject, obj[PG.RESOURCES])[RES.XOBJECT]
+ )
+ except KeyError:
+ if not (id[0] == "~" and id[-1] == "~"):
+ raise
+ if isinstance(id, str):
+ if id[0] == "~" and id[-1] == "~":
+ if self.inline_images is None:
+ self.inline_images = self._get_inline_images()
+ if self.inline_images is None: # pragma: no cover
+ raise KeyError("No inline image can be found")
+ return self.inline_images[id]
+
+ from ._xobj_image_helpers import _xobj_to_image # noqa: PLC0415
+ imgd = _xobj_to_image(cast(DictionaryObject, xobjs[id]))
+ extension, byte_stream = imgd[:2]
+ return ImageFile(
+ name=f"{id[1:]}{extension}",
+ data=byte_stream,
+ image=imgd[2],
+ indirect_reference=xobjs[id].indirect_reference,
+ )
+ # in a subobject
+ ids = id[1:]
+ return self._get_image(ids, cast(DictionaryObject, xobjs[id[0]]))
+
+ @property
+ def images(self) -> VirtualListImages:
+ """
+ Read-only property emulating a list of images on a page.
+
+ Get a list of all images on the page. The key can be:
+ - A string (for the top object)
+ - A tuple (for images within XObject forms)
+ - An integer
+
+ Examples:
+ * `reader.pages[0].images[0]` # return first image
+ * `reader.pages[0].images['/I0']` # return image '/I0'
+ * `reader.pages[0].images['/TP1','/Image1']` # return image '/Image1' within '/TP1' XObject form
+ * `for img in reader.pages[0].images:` # loops through all objects
+
+ images.keys() and images.items() can be used.
+
+ The ImageFile has the following properties:
+
+ * `.name` : name of the object
+ * `.data` : bytes of the object
+ * `.image` : PIL Image Object
+ * `.indirect_reference` : object reference
+
+ and the following methods:
+ `.replace(new_image: PIL.Image.Image, **kwargs)` :
+ replace the image in the pdf with the new image
+ applying the saving parameters indicated (such as quality)
+
+ Example usage:
+
+ reader.pages[0].images[0].replace(Image.open("new_image.jpg"), quality=20)
+
+ Inline images are extracted and named ~0~, ~1~, ..., with the
+ indirect_reference set to None.
+
+ """
+ return VirtualListImages(self._get_ids_image, self._get_image)
+
+ def _translate_value_inline_image(self, k: str, v: PdfObject) -> PdfObject:
+ """Translate values used in inline image"""
+ try:
+ v = NameObject(_INLINE_IMAGE_VALUE_MAPPING[cast(str, v)])
+ except (TypeError, KeyError):
+ if isinstance(v, NameObject):
+ # It is a custom name, thus we have to look in resources.
+ # The only applicable case is for ColorSpace.
+ try:
+ res = cast(DictionaryObject, self["/Resources"])["/ColorSpace"]
+ v = cast(DictionaryObject, res)[v]
+ except KeyError: # for res and v
+ raise PdfReadError(f"Cannot find resource entry {v} for {k}")
+ return v
+
+ def _get_inline_images(self) -> dict[str, ImageFile]:
+ """Load inline images. Entries will be identified as `~1~`."""
+ content = self.get_contents()
+ if is_null_or_none(content):
+ return {}
+ imgs_data = []
+ assert content is not None, "mypy"
+ for param, ope in content.operations:
+ if ope == b"INLINE IMAGE":
+ imgs_data.append(
+ {"settings": param["settings"], "__streamdata__": param["data"]}
+ )
+ elif ope in (b"BI", b"EI", b"ID"): # pragma: no cover
+ raise PdfReadError(
+ f"{ope!r} operator met whereas not expected, "
+ "please share use case with pypdf dev team"
+ )
+ files = {}
+ for num, ii in enumerate(imgs_data):
+ init = {
+ "__streamdata__": ii["__streamdata__"],
+ "/Length": len(ii["__streamdata__"]),
+ }
+ for k, v in ii["settings"].items():
+ if k in {"/Length", "/L"}: # no length is expected
+ continue
+ if isinstance(v, list):
+ v = ArrayObject(
+ [self._translate_value_inline_image(k, x) for x in v]
+ )
+ else:
+ v = self._translate_value_inline_image(k, v)
+ k = NameObject(_INLINE_IMAGE_KEY_MAPPING[k])
+ if k not in init:
+ init[k] = v
+ ii["object"] = EncodedStreamObject.initialize_from_dictionary(init)
+ from ._xobj_image_helpers import _xobj_to_image # noqa: PLC0415
+ extension, byte_stream, img = _xobj_to_image(ii["object"])
+ files[f"~{num}~"] = ImageFile(
+ name=f"~{num}~{extension}",
+ data=byte_stream,
+ image=img,
+ indirect_reference=None,
+ )
+ return files
+
+ @property
+ def rotation(self) -> int:
+ """
+ The visual rotation of the page.
+
+ This number has to be a multiple of 90 degrees: 0, 90, 180, or 270 are
+ valid values. This property does not affect ``/Contents``.
+ """
+ rotate_obj = self.get(PG.ROTATE, 0)
+ return rotate_obj if isinstance(rotate_obj, int) else rotate_obj.get_object()
+
+ @rotation.setter
+ def rotation(self, r: float) -> None:
+ self[NameObject(PG.ROTATE)] = NumberObject((((int(r) + 45) // 90) * 90) % 360)
+
+ def transfer_rotation_to_content(self) -> None:
+ """
+ Apply the rotation of the page to the content and the media/crop/...
+ boxes.
+
+ It is recommended to apply this function before page merging.
+ """
+ r = -self.rotation # rotation to apply is in the otherway
+ self.rotation = 0
+ mb = RectangleObject(self.mediabox)
+ trsf = (
+ Transformation()
+ .translate(
+ -float(mb.left + mb.width / 2), -float(mb.bottom + mb.height / 2)
+ )
+ .rotate(r)
+ )
+ pt1 = trsf.apply_on(mb.lower_left)
+ pt2 = trsf.apply_on(mb.upper_right)
+ trsf = trsf.translate(-min(pt1[0], pt2[0]), -min(pt1[1], pt2[1]))
+ self.add_transformation(trsf, False)
+ for b in ["/MediaBox", "/CropBox", "/BleedBox", "/TrimBox", "/ArtBox"]:
+ if b in self:
+ rr = RectangleObject(self[b]) # type: ignore
+ pt1 = trsf.apply_on(rr.lower_left)
+ pt2 = trsf.apply_on(rr.upper_right)
+ self[NameObject(b)] = RectangleObject(
+ (
+ min(pt1[0], pt2[0]),
+ min(pt1[1], pt2[1]),
+ max(pt1[0], pt2[0]),
+ max(pt1[1], pt2[1]),
+ )
+ )
+
+ def rotate(self, angle: int) -> "PageObject":
+ """
+ Rotate a page clockwise by increments of 90 degrees.
+
+ Args:
+ angle: Angle to rotate the page. Must be an increment of 90 deg.
+
+ Returns:
+ The rotated PageObject
+
+ """
+ if angle % 90 != 0:
+ raise ValueError("Rotation angle must be a multiple of 90")
+ self[NameObject(PG.ROTATE)] = NumberObject(self.rotation + angle)
+ return self
+
+ def _merge_resources(
+ self,
+ res1: DictionaryObject,
+ res2: DictionaryObject,
+ resource: Any,
+ new_res1: bool = True,
+ ) -> tuple[dict[str, Any], dict[str, Any]]:
+ try:
+ assert isinstance(self.indirect_reference, IndirectObject)
+ pdf = self.indirect_reference.pdf
+ is_pdf_writer = hasattr(
+ pdf, "_add_object"
+ ) # expect isinstance(pdf, PdfWriter)
+ except (AssertionError, AttributeError):
+ pdf = None
+ is_pdf_writer = False
+
+ def compute_unique_key(base_key: str) -> tuple[str, bool]:
+ """
+ Find a key that either doesn't already exist or has the same value
+ (indicated by the bool)
+
+ Args:
+ base_key: An index is added to this to get the computed key
+
+ Returns:
+ A tuple (computed key, bool) where the boolean indicates
+ if there is a resource of the given computed_key with the same
+ value.
+
+ """
+ value = page2res.raw_get(base_key)
+ # TODO: a possible improvement for writer, the indirect_reference
+ # cannot be found because translated
+
+ # try the current key first (e.g. "foo"), but otherwise iterate
+ # through "foo-0", "foo-1", etc. new_res can contain only finitely
+ # many keys, thus this'll eventually end, even if it's been crafted
+ # to be maximally annoying.
+ computed_key = base_key
+ idx = 0
+ while computed_key in new_res:
+ if new_res.raw_get(computed_key) == value:
+ # there's already a resource of this name, with the exact
+ # same value
+ return computed_key, True
+ computed_key = f"{base_key}-{idx}"
+ idx += 1
+ return computed_key, False
+
+ if new_res1:
+ new_res = DictionaryObject()
+ new_res.update(res1.get(resource, DictionaryObject()).get_object())
+ else:
+ new_res = cast(DictionaryObject, res1[resource])
+ page2res = cast(
+ DictionaryObject, res2.get(resource, DictionaryObject()).get_object()
+ )
+ rename_res = {}
+ for key in page2res:
+ unique_key, same_value = compute_unique_key(key)
+ newname = NameObject(unique_key)
+ if key != unique_key:
+ # we have to use a different name for this
+ rename_res[key] = newname
+
+ if not same_value:
+ if is_pdf_writer:
+ new_res[newname] = page2res.raw_get(key).clone(pdf)
+ try:
+ new_res[newname] = new_res[newname].indirect_reference
+ except AttributeError:
+ pass
+ else:
+ new_res[newname] = page2res.raw_get(key)
+ lst = sorted(new_res.items())
+ new_res.clear()
+ for el in lst:
+ new_res[el[0]] = el[1]
+ return new_res, rename_res
+
+ @staticmethod
+ def _content_stream_rename(
+ stream: ContentStream,
+ rename: dict[Any, Any],
+ pdf: Optional[PdfCommonDocProtocol],
+ ) -> ContentStream:
+ if not rename:
+ return stream
+ stream = ContentStream(stream, pdf)
+ for operands, _operator in stream.operations:
+ if isinstance(operands, list):
+ for i, op in enumerate(operands):
+ if isinstance(op, NameObject):
+ operands[i] = rename.get(op, op)
+ elif isinstance(operands, dict):
+ for i, op in operands.items():
+ if isinstance(op, NameObject):
+ operands[i] = rename.get(op, op)
+ else:
+ raise KeyError(f"Type of operands is {type(operands)}")
+ return stream
+
+ @staticmethod
+ def _add_transformation_matrix(
+ contents: Any,
+ pdf: Optional[PdfCommonDocProtocol],
+ ctm: CompressedTransformationMatrix,
+ ) -> ContentStream:
+ """Add transformation matrix at the beginning of the given contents stream."""
+ contents = ContentStream(contents, pdf)
+ contents.operations.insert(
+ 0,
+ [
+ [FloatObject(x) for x in ctm],
+ b"cm",
+ ],
+ )
+ return contents
+
+ def _get_contents_as_bytes(self) -> Optional[bytes]:
+ """
+ Return the page contents as bytes.
+
+ Returns:
+ The ``/Contents`` object as bytes, or ``None`` if it doesn't exist.
+
+ """
+ if PG.CONTENTS in self:
+ obj = self[PG.CONTENTS].get_object()
+ if isinstance(obj, list):
+ return b"".join(x.get_object().get_data() for x in obj)
+ return cast(EncodedStreamObject, obj).get_data()
+ return None
+
+ def get_contents(self) -> Optional[ContentStream]:
+ """
+ Access the page contents.
+
+ Returns:
+ The ``/Contents`` object, or ``None`` if it does not exist.
+ ``/Contents`` is optional, as described in §7.7.3.3 of the PDF Reference.
+
+ """
+ if PG.CONTENTS in self:
+ try:
+ pdf = cast(IndirectObject, self.indirect_reference).pdf
+ except AttributeError:
+ pdf = None
+ obj = self[PG.CONTENTS]
+ if is_null_or_none(obj):
+ return None
+ resolved_object = obj.get_object()
+ return ContentStream(resolved_object, pdf)
+ return None
+
+ def replace_contents(
+ self, content: Union[None, ContentStream, EncodedStreamObject, ArrayObject]
+ ) -> None:
+ """
+ Replace the page contents with the new content and nullify old objects
+ Args:
+ content: new content; if None delete the content field.
+ """
+ if not hasattr(self, "indirect_reference") or self.indirect_reference is None:
+ # the page is not attached : the content is directly attached.
+ self[NameObject(PG.CONTENTS)] = content
+ return
+
+ from pypdf._writer import PdfWriter # noqa: PLC0415
+ if not isinstance(self.indirect_reference.pdf, PdfWriter):
+ deprecate(
+ "Calling `PageObject.replace_contents()` for pages not assigned to a writer is deprecated "
+ "and will be removed in pypdf 7.0.0. Attach the page to the writer first or use "
+ "`PdfWriter(clone_from=...)` directly. The existing approach has proved being unreliable."
+ )
+
+ if isinstance(self.get(PG.CONTENTS, None), ArrayObject):
+ for o in self[PG.CONTENTS]: # type: ignore[attr-defined]
+ try:
+ self.indirect_reference.pdf._objects[
+ o.indirect_reference.idnum - 1
+ ] = NullObject()
+ except AttributeError:
+ pass
+
+ if isinstance(content, ArrayObject):
+ content = ArrayObject(self.indirect_reference.pdf._add_object(obj) for obj in content)
+
+ if is_null_or_none(content):
+ if PG.CONTENTS not in self:
+ return
+ assert self.indirect_reference is not None
+ assert self[PG.CONTENTS].indirect_reference is not None
+ self.indirect_reference.pdf._objects[
+ self[PG.CONTENTS].indirect_reference.idnum - 1 # type: ignore
+ ] = NullObject()
+ del self[PG.CONTENTS]
+ elif not hasattr(self.get(PG.CONTENTS, None), "indirect_reference"):
+ try:
+ self[NameObject(PG.CONTENTS)] = self.indirect_reference.pdf._add_object(
+ content
+ )
+ except AttributeError:
+ # applies at least for page not in writer
+ # as a backup solution, we put content as an object although not in accordance with pdf ref
+ # this will be fixed with the _add_object
+ self[NameObject(PG.CONTENTS)] = content
+ else:
+ assert content is not None, "mypy"
+ content.indirect_reference = self[
+ PG.CONTENTS
+ ].indirect_reference # TODO: in the future may require generation management
+ try:
+ self.indirect_reference.pdf._objects[
+ content.indirect_reference.idnum - 1 # type: ignore
+ ] = content
+ except AttributeError:
+ # applies at least for page not in writer
+ # as a backup solution, we put content as an object although not in accordance with pdf ref
+ # this will be fixed with the _add_object
+ self[NameObject(PG.CONTENTS)] = content
+ # forces recalculation of inline_images
+ self.inline_images = None
+
+ def merge_page(
+ self, page2: "PageObject", expand: bool = False, over: bool = True
+ ) -> None:
+ """
+ Merge the content streams of two pages into one.
+
+ Resource references (e.g. fonts) are maintained from both pages.
+ The mediabox, cropbox, etc of this page are not altered.
+ The parameter page's content stream will
+ be added to the end of this page's content stream,
+ meaning that it will be drawn after, or "on top" of this page.
+
+ Args:
+ page2: The page to be merged into this one. Should be
+ an instance of :class:`PageObject`.
+ over: set the page2 content over page1 if True (default) else under
+ expand: If True, the current page dimensions will be
+ expanded to accommodate the dimensions of the page to be merged.
+
+ """
+ self._merge_page(page2, over=over, expand=expand)
+
+ def _merge_page(
+ self,
+ page2: "PageObject",
+ page2transformation: Optional[Callable[[Any], ContentStream]] = None,
+ ctm: Optional[CompressedTransformationMatrix] = None,
+ over: bool = True,
+ expand: bool = False,
+ ) -> None:
+ # First we work on merging the resource dictionaries. This allows us
+ # to find out what symbols in the content streams we might need to
+ # rename.
+ try:
+ assert isinstance(self.indirect_reference, IndirectObject)
+ if hasattr(
+ self.indirect_reference.pdf, "_add_object"
+ ): # to detect PdfWriter
+ return self._merge_page_writer(
+ page2, page2transformation, ctm, over, expand
+ )
+ except (AssertionError, AttributeError):
+ pass
+
+ new_resources = DictionaryObject()
+ rename = {}
+ original_resources = cast(DictionaryObject, self.get(PG.RESOURCES, DictionaryObject()).get_object())
+ page2resources = cast(DictionaryObject, page2.get(PG.RESOURCES, DictionaryObject()).get_object())
+ new_annots = ArrayObject()
+
+ for page in (self, page2):
+ if PG.ANNOTS in page:
+ annots = page[PG.ANNOTS]
+ if isinstance(annots, ArrayObject):
+ new_annots.extend(annots)
+
+ for res in (
+ RES.EXT_G_STATE,
+ RES.FONT,
+ RES.XOBJECT,
+ RES.COLOR_SPACE,
+ RES.PATTERN,
+ RES.SHADING,
+ RES.PROPERTIES,
+ ):
+ new, newrename = self._merge_resources(
+ original_resources, page2resources, res
+ )
+ if new:
+ new_resources[NameObject(res)] = new
+ rename.update(newrename)
+
+ # Combine /ProcSet sets, making sure there's a consistent order
+ new_resources[NameObject(RES.PROC_SET)] = ArrayObject(
+ sorted(
+ set(
+ original_resources.get(RES.PROC_SET, ArrayObject()).get_object()
+ ).union(
+ set(page2resources.get(RES.PROC_SET, ArrayObject()).get_object())
+ )
+ )
+ )
+
+ new_content_array = ArrayObject()
+ original_content = self.get_contents()
+ if original_content is not None:
+ original_content.isolate_graphics_state()
+ new_content_array.append(original_content)
+
+ page2content = page2.get_contents()
+ if page2content is not None:
+ rect = getattr(page2, MERGE_CROP_BOX)
+ page2content.operations.insert(
+ 0,
+ (
+ map(
+ FloatObject,
+ [
+ rect.left,
+ rect.bottom,
+ rect.width,
+ rect.height,
+ ],
+ ),
+ b"re",
+ ),
+ )
+ page2content.operations.insert(1, ([], b"W"))
+ page2content.operations.insert(2, ([], b"n"))
+ if page2transformation is not None:
+ page2content = page2transformation(page2content)
+ page2content = PageObject._content_stream_rename(
+ page2content, rename, self.pdf
+ )
+ page2content.isolate_graphics_state()
+ if over:
+ new_content_array.append(page2content)
+ else:
+ new_content_array.insert(0, page2content)
+
+ # if expanding the page to fit a new page, calculate the new media box size
+ if expand:
+ self._expand_mediabox(page2, ctm)
+
+ self.replace_contents(ContentStream(new_content_array, self.pdf))
+ self[NameObject(PG.RESOURCES)] = new_resources
+ self[NameObject(PG.ANNOTS)] = new_annots
+ return None
+
+ def _merge_page_writer(
+ self,
+ page2: "PageObject",
+ page2transformation: Optional[Callable[[Any], ContentStream]] = None,
+ ctm: Optional[CompressedTransformationMatrix] = None,
+ over: bool = True,
+ expand: bool = False,
+ ) -> None:
+ # First we work on merging the resource dictionaries. This allows us
+ # to find which symbols in the content streams we might need to
+ # rename.
+ assert isinstance(self.indirect_reference, IndirectObject)
+ pdf = self.indirect_reference.pdf
+
+ rename = {}
+ if PG.RESOURCES not in self:
+ self[NameObject(PG.RESOURCES)] = DictionaryObject()
+ original_resources = cast(DictionaryObject, self[PG.RESOURCES].get_object())
+ if PG.RESOURCES not in page2:
+ page2resources = DictionaryObject()
+ else:
+ page2resources = cast(DictionaryObject, page2[PG.RESOURCES].get_object())
+
+ for res in (
+ RES.EXT_G_STATE,
+ RES.FONT,
+ RES.XOBJECT,
+ RES.COLOR_SPACE,
+ RES.PATTERN,
+ RES.SHADING,
+ RES.PROPERTIES,
+ ):
+ if res in page2resources:
+ if res not in original_resources:
+ original_resources[NameObject(res)] = DictionaryObject()
+ _, newrename = self._merge_resources(
+ original_resources, page2resources, res, False
+ )
+ rename.update(newrename)
+ # Combine /ProcSet sets.
+ if RES.PROC_SET in page2resources:
+ if RES.PROC_SET not in original_resources:
+ original_resources[NameObject(RES.PROC_SET)] = ArrayObject()
+ arr = cast(ArrayObject, original_resources[RES.PROC_SET])
+ for x in cast(ArrayObject, page2resources[RES.PROC_SET]):
+ if x not in arr:
+ arr.append(x)
+ arr.sort()
+
+ if PG.ANNOTS in page2:
+ if PG.ANNOTS not in self:
+ self[NameObject(PG.ANNOTS)] = ArrayObject()
+ annots = cast(ArrayObject, self[PG.ANNOTS].get_object())
+ if ctm is None:
+ trsf = Transformation()
+ else:
+ trsf = Transformation(ctm)
+ # Ensure we are working on a copy of the list. Otherwise, if both pages
+ # are the same object, we might run into an infinite loop.
+ for a in cast(ArrayObject, deepcopy(page2[PG.ANNOTS])):
+ a = a.get_object()
+ aa = a.clone(
+ pdf,
+ ignore_fields=("/P", "/StructParent", "/Parent"),
+ force_duplicate=True,
+ )
+ r = cast(ArrayObject, a["/Rect"])
+ pt1 = trsf.apply_on((r[0], r[1]), True)
+ pt2 = trsf.apply_on((r[2], r[3]), True)
+ aa[NameObject("/Rect")] = ArrayObject(
+ (
+ min(pt1[0], pt2[0]),
+ min(pt1[1], pt2[1]),
+ max(pt1[0], pt2[0]),
+ max(pt1[1], pt2[1]),
+ )
+ )
+ if "/QuadPoints" in a:
+ q = cast(ArrayObject, a["/QuadPoints"])
+ aa[NameObject("/QuadPoints")] = ArrayObject(
+ trsf.apply_on((q[0], q[1]), True)
+ + trsf.apply_on((q[2], q[3]), True)
+ + trsf.apply_on((q[4], q[5]), True)
+ + trsf.apply_on((q[6], q[7]), True)
+ )
+ try:
+ aa["/Popup"][NameObject("/Parent")] = aa.indirect_reference
+ except KeyError:
+ pass
+ try:
+ aa[NameObject("/P")] = self.indirect_reference
+ annots.append(aa.indirect_reference)
+ except AttributeError:
+ pass
+
+ new_content_array = ArrayObject()
+ original_content = self.get_contents()
+ if original_content is not None:
+ original_content.isolate_graphics_state()
+ new_content_array.append(original_content)
+
+ page2content = page2.get_contents()
+ if page2content is not None:
+ rect = getattr(page2, MERGE_CROP_BOX)
+ page2content.operations.insert(
+ 0,
+ (
+ map(
+ FloatObject,
+ [
+ rect.left,
+ rect.bottom,
+ rect.width,
+ rect.height,
+ ],
+ ),
+ b"re",
+ ),
+ )
+ page2content.operations.insert(1, ([], b"W"))
+ page2content.operations.insert(2, ([], b"n"))
+ if page2transformation is not None:
+ page2content = page2transformation(page2content)
+ page2content = PageObject._content_stream_rename(
+ page2content, rename, self.pdf
+ )
+ page2content.isolate_graphics_state()
+ if over:
+ new_content_array.append(page2content)
+ else:
+ new_content_array.insert(0, page2content)
+
+ # if expanding the page to fit a new page, calculate the new media box size
+ if expand:
+ self._expand_mediabox(page2, ctm)
+
+ self.replace_contents(new_content_array)
+
+ def _expand_mediabox(
+ self, page2: "PageObject", ctm: Optional[CompressedTransformationMatrix]
+ ) -> None:
+ corners1 = (
+ self.mediabox.left.as_numeric(),
+ self.mediabox.bottom.as_numeric(),
+ self.mediabox.right.as_numeric(),
+ self.mediabox.top.as_numeric(),
+ )
+ corners2 = (
+ page2.mediabox.left.as_numeric(),
+ page2.mediabox.bottom.as_numeric(),
+ page2.mediabox.left.as_numeric(),
+ page2.mediabox.top.as_numeric(),
+ page2.mediabox.right.as_numeric(),
+ page2.mediabox.top.as_numeric(),
+ page2.mediabox.right.as_numeric(),
+ page2.mediabox.bottom.as_numeric(),
+ )
+ if ctm is not None:
+ ctm = tuple(float(x) for x in ctm) # type: ignore[assignment]
+ new_x = tuple(
+ ctm[0] * corners2[i] + ctm[2] * corners2[i + 1] + ctm[4]
+ for i in range(0, 8, 2)
+ )
+ new_y = tuple(
+ ctm[1] * corners2[i] + ctm[3] * corners2[i + 1] + ctm[5]
+ for i in range(0, 8, 2)
+ )
+ else:
+ new_x = corners2[0:8:2]
+ new_y = corners2[1:8:2]
+ lowerleft = (min(new_x), min(new_y))
+ upperright = (max(new_x), max(new_y))
+ lowerleft = (min(corners1[0], lowerleft[0]), min(corners1[1], lowerleft[1]))
+ upperright = (
+ max(corners1[2], upperright[0]),
+ max(corners1[3], upperright[1]),
+ )
+
+ self.mediabox.lower_left = lowerleft
+ self.mediabox.upper_right = upperright
+
+ def merge_transformed_page(
+ self,
+ page2: "PageObject",
+ ctm: Union[CompressedTransformationMatrix, Transformation],
+ over: bool = True,
+ expand: bool = False,
+ ) -> None:
+ """
+ Similar to :meth:`~pypdf._page.PageObject.merge_page`, but a transformation
+ matrix is applied to the merged stream.
+
+ Args:
+ page2: The page to be merged into this one.
+ ctm: a 6-element tuple containing the operands of the
+ transformation matrix
+ over: set the page2 content over page1 if True (default) else under
+ expand: Whether the page should be expanded to fit the dimensions
+ of the page to be merged.
+
+ """
+ if isinstance(ctm, Transformation):
+ ctm = ctm.ctm
+ self._merge_page(
+ page2,
+ lambda page2_content: PageObject._add_transformation_matrix(
+ page2_content, page2.pdf, ctm
+ ),
+ ctm,
+ over,
+ expand,
+ )
+
+ def merge_scaled_page(
+ self, page2: "PageObject", scale: float, over: bool = True, expand: bool = False
+ ) -> None:
+ """
+ Similar to :meth:`~pypdf._page.PageObject.merge_page`, but the stream to be merged
+ is scaled by applying a transformation matrix.
+
+ Args:
+ page2: The page to be merged into this one.
+ scale: The scaling factor
+ over: set the page2 content over page1 if True (default) else under
+ expand: Whether the page should be expanded to fit the
+ dimensions of the page to be merged.
+
+ """
+ op = Transformation().scale(scale, scale)
+ self.merge_transformed_page(page2, op, over, expand)
+
+ def merge_rotated_page(
+ self,
+ page2: "PageObject",
+ rotation: float,
+ over: bool = True,
+ expand: bool = False,
+ ) -> None:
+ """
+ Similar to :meth:`~pypdf._page.PageObject.merge_page`, but the stream to be merged
+ is rotated by applying a transformation matrix.
+
+ Args:
+ page2: The page to be merged into this one.
+ rotation: The angle of the rotation, in degrees
+ over: set the page2 content over page1 if True (default) else under
+ expand: Whether the page should be expanded to fit the
+ dimensions of the page to be merged.
+
+ """
+ op = Transformation().rotate(rotation)
+ self.merge_transformed_page(page2, op, over, expand)
+
+ def merge_translated_page(
+ self,
+ page2: "PageObject",
+ tx: float,
+ ty: float,
+ over: bool = True,
+ expand: bool = False,
+ ) -> None:
+ """
+ Similar to :meth:`~pypdf._page.PageObject.merge_page`, but the stream to be
+ merged is translated by applying a transformation matrix.
+
+ Args:
+ page2: the page to be merged into this one.
+ tx: The translation on X axis
+ ty: The translation on Y axis
+ over: set the page2 content over page1 if True (default) else under
+ expand: Whether the page should be expanded to fit the
+ dimensions of the page to be merged.
+
+ """
+ op = Transformation().translate(tx, ty)
+ self.merge_transformed_page(page2, op, over, expand)
+
+ def add_transformation(
+ self,
+ ctm: Union[Transformation, CompressedTransformationMatrix],
+ expand: bool = False,
+ ) -> None:
+ """
+ Apply a transformation matrix to the page.
+
+ Args:
+ ctm: A 6-element tuple containing the operands of the
+ transformation matrix. Alternatively, a
+ :py:class:`Transformation`
+ object can be passed.
+
+ See :doc:`/user/cropping-and-transforming`.
+
+ """
+ if isinstance(ctm, Transformation):
+ ctm = ctm.ctm
+ content = self.get_contents()
+ if content is not None:
+ content = PageObject._add_transformation_matrix(content, self.pdf, ctm)
+ content.isolate_graphics_state()
+ self.replace_contents(content)
+ # if expanding the page to fit a new page, calculate the new media box size
+ if expand:
+ corners = [
+ self.mediabox.left.as_numeric(),
+ self.mediabox.bottom.as_numeric(),
+ self.mediabox.left.as_numeric(),
+ self.mediabox.top.as_numeric(),
+ self.mediabox.right.as_numeric(),
+ self.mediabox.top.as_numeric(),
+ self.mediabox.right.as_numeric(),
+ self.mediabox.bottom.as_numeric(),
+ ]
+
+ ctm = tuple(float(x) for x in ctm) # type: ignore[assignment]
+ new_x = [
+ ctm[0] * corners[i] + ctm[2] * corners[i + 1] + ctm[4]
+ for i in range(0, 8, 2)
+ ]
+ new_y = [
+ ctm[1] * corners[i] + ctm[3] * corners[i + 1] + ctm[5]
+ for i in range(0, 8, 2)
+ ]
+
+ self.mediabox.lower_left = (min(new_x), min(new_y))
+ self.mediabox.upper_right = (max(new_x), max(new_y))
+
+ def scale(self, sx: float, sy: float) -> None:
+ """
+ Scale a page by the given factors by applying a transformation matrix
+ to its content and updating the page size.
+
+ This updates the various page boundaries (bleedbox, trimbox, etc.)
+ and the contents of the page.
+
+ Args:
+ sx: The scaling factor on horizontal axis.
+ sy: The scaling factor on vertical axis.
+
+ """
+ self.add_transformation((sx, 0, 0, sy, 0, 0))
+ self.bleedbox = self.bleedbox.scale(sx, sy)
+ self.trimbox = self.trimbox.scale(sx, sy)
+ self.artbox = self.artbox.scale(sx, sy)
+ self.cropbox = self.cropbox.scale(sx, sy)
+ self.mediabox = self.mediabox.scale(sx, sy)
+
+ if PG.ANNOTS in self:
+ annotations = self[PG.ANNOTS]
+ if isinstance(annotations, ArrayObject):
+ for annotation in annotations:
+ annotation_obj = annotation.get_object()
+ if ADA.Rect in annotation_obj:
+ rectangle = annotation_obj[ADA.Rect]
+ if isinstance(rectangle, ArrayObject):
+ rectangle[0] = FloatObject(float(rectangle[0]) * sx)
+ rectangle[1] = FloatObject(float(rectangle[1]) * sy)
+ rectangle[2] = FloatObject(float(rectangle[2]) * sx)
+ rectangle[3] = FloatObject(float(rectangle[3]) * sy)
+
+ if PG.VP in self:
+ viewport = self[PG.VP]
+ if isinstance(viewport, ArrayObject):
+ bbox = viewport[0]["/BBox"]
+ else:
+ bbox = viewport["/BBox"] # type: ignore
+ scaled_bbox = RectangleObject(
+ (
+ float(bbox[0]) * sx,
+ float(bbox[1]) * sy,
+ float(bbox[2]) * sx,
+ float(bbox[3]) * sy,
+ )
+ )
+ if isinstance(viewport, ArrayObject):
+ self[NameObject(PG.VP)][NumberObject(0)][ # type: ignore
+ NameObject("/BBox")
+ ] = scaled_bbox
+ else:
+ self[NameObject(PG.VP)][NameObject("/BBox")] = scaled_bbox # type: ignore
+
+ def scale_by(self, factor: float) -> None:
+ """
+ Scale a page by the given factor by applying a transformation matrix to
+ its content and updating the page size.
+
+ Args:
+ factor: The scaling factor (for both X and Y axis).
+
+ """
+ self.scale(factor, factor)
+
+ def scale_to(self, width: float, height: float) -> None:
+ """
+ Scale a page to the specified dimensions by applying a transformation
+ matrix to its content and updating the page size.
+
+ Args:
+ width: The new width.
+ height: The new height.
+
+ """
+ sx = width / float(self.mediabox.width)
+ sy = height / float(self.mediabox.height)
+ self.scale(sx, sy)
+
+ def compress_content_streams(self, level: int = -1) -> None:
+ """
+ Compress the size of this page by joining all content streams and
+ applying a FlateDecode filter.
+
+ However, it is possible that this function will perform no action if
+ content stream compression becomes "automatic".
+ """
+ content = self.get_contents()
+ if content is not None:
+ content_obj = content.flate_encode(level)
+ try:
+ content.indirect_reference.pdf._objects[ # type: ignore
+ content.indirect_reference.idnum - 1 # type: ignore
+ ] = content_obj
+ except AttributeError:
+ if self.indirect_reference is not None and hasattr(
+ self.indirect_reference.pdf, "_add_object"
+ ):
+ self.replace_contents(content_obj)
+ else:
+ raise ValueError("Page must be part of a PdfWriter")
+
+ @property
+ def page_number(self) -> Optional[int]:
+ """
+ Read-only property which returns the page number within the PDF file.
+
+ Returns:
+ Page number; None if the page is not attached to a PDF.
+
+ """
+ if self.indirect_reference is None:
+ return None
+ try:
+ lst = self.indirect_reference.pdf.pages
+ return lst.index(self)
+ except ValueError:
+ return None
+
+ def _debug_for_extract(self) -> str: # pragma: no cover
+ out = ""
+ for ope, op in ContentStream(
+ self["/Contents"].get_object(), self.pdf, "bytes"
+ ).operations:
+ if op == b"TJ":
+ s = [x for x in ope[0] if isinstance(x, str)]
+ else:
+ s = []
+ out += op.decode("utf-8") + " " + "".join(s) + ope.__repr__() + "\n"
+ out += "\n=============================\n"
+ try:
+ for fo in self[PG.RESOURCES]["/Font"]: # type:ignore
+ out += fo + "\n"
+ out += self[PG.RESOURCES]["/Font"][fo].__repr__() + "\n" # type:ignore
+ try:
+ enc_repr = self[PG.RESOURCES]["/Font"][fo][ # type:ignore
+ "/Encoding"
+ ].__repr__()
+ out += enc_repr + "\n"
+ except Exception:
+ pass
+ try:
+ out += (
+ self[PG.RESOURCES]["/Font"][fo][ # type:ignore
+ "/ToUnicode"
+ ]
+ .get_data()
+ .decode()
+ + "\n"
+ )
+ except Exception:
+ pass
+
+ except KeyError:
+ out += "No Font\n"
+ return out
+
+ def _extract_text(
+ self,
+ obj: Any,
+ pdf: Any,
+ orientations: tuple[int, ...] = (0, 90, 180, 270),
+ space_width: float = 200.0,
+ content_key: Optional[str] = PG.CONTENTS,
+ visitor_operand_before: Optional[Callable[[Any, Any, Any, Any], None]] = None,
+ visitor_operand_after: Optional[Callable[[Any, Any, Any, Any], None]] = None,
+ visitor_text: Optional[Callable[[Any, Any, Any, Any, Any], None]] = None,
+ ) -> str:
+ """
+ See extract_text for most arguments.
+
+ Args:
+ content_key: indicate the default key where to extract data
+ None = the object; this allows reusing the function on an XObject
+ default = "/Content"
+
+ """
+ extractor = TextExtraction()
+ font_resources: dict[str, DictionaryObject] = {}
+ fonts: dict[str, Font] = {}
+
+ try:
+ objr = obj
+ while NameObject(PG.RESOURCES) not in objr:
+ # /Resources can be inherited so we look to parents
+ objr = objr["/Parent"].get_object()
+ # If no parents then no /Resources will be available,
+ # so an exception will be raised
+ resources_dict = cast(DictionaryObject, objr[PG.RESOURCES])
+ except Exception:
+ # No resources means no text is possible (no font); we consider the
+ # file as not damaged, no need to check for TJ or Tj
+ return ""
+
+ if (
+ not is_null_or_none(resources_dict)
+ and "/Font" in resources_dict
+ and (font_resources_dict := cast(DictionaryObject, resources_dict["/Font"]))
+ ):
+ for font_resource in font_resources_dict:
+ try:
+ font_resource_object = cast(DictionaryObject, font_resources_dict[font_resource].get_object())
+ font_resources[font_resource] = font_resource_object
+ fonts[font_resource] = Font.from_font_resource(font_resource_object)
+ # Override space width, if applicable
+ if fonts[font_resource].character_widths.get(" ", 0) == 0:
+ fonts[font_resource].space_width = space_width
+ except (AttributeError, TypeError):
+ pass
+
+ try:
+ content = (
+ obj[content_key].get_object() if isinstance(content_key, str) else obj
+ )
+ if not isinstance(content, ContentStream):
+ content = ContentStream(content, pdf, "bytes")
+ except (AttributeError, KeyError): # no content can be extracted (certainly empty page)
+ return ""
+ # We check all strings are TextStringObjects. ByteStringObjects
+ # are strings where the byte->string encoding was unknown, so adding
+ # them to the text here would be gibberish.
+
+ # Initialize the extractor with the necessary parameters
+ extractor.initialize_extraction(orientations, visitor_text, font_resources, fonts)
+
+ for operands, operator in content.operations:
+ if visitor_operand_before is not None:
+ visitor_operand_before(operator, operands, extractor.cm_matrix, extractor.tm_matrix)
+ # Multiple operators are handled here
+ if operator == b"'":
+ extractor.process_operation(b"T*", [])
+ extractor.process_operation(b"Tj", operands)
+ elif operator == b'"':
+ extractor.process_operation(b"Tw", [operands[0]])
+ extractor.process_operation(b"Tc", [operands[1]])
+ extractor.process_operation(b"T*", [])
+ extractor.process_operation(b"Tj", operands[2:])
+ elif operator == b"TJ":
+ # The space width may be smaller than the font width, so the width should be 95%.
+ _confirm_space_width = extractor._space_width * 0.95
+ if operands:
+ for op in operands[0]:
+ if isinstance(op, (str, bytes)):
+ extractor.process_operation(b"Tj", [op])
+ if isinstance(op, (int, float, NumberObject, FloatObject)) and (
+ abs(float(op)) >= _confirm_space_width
+ and extractor.text
+ and extractor.text[-1] != " "
+ ):
+ extractor.process_operation(b"Tj", [" "])
+ elif operator == b"TD":
+ extractor.process_operation(b"TL", [-operands[1]])
+ extractor.process_operation(b"Td", operands)
+ elif operator == b"Do":
+ extractor.output += extractor.text
+ if visitor_text is not None:
+ visitor_text(
+ extractor.text,
+ extractor.memo_cm,
+ extractor.memo_tm,
+ extractor.font_resource,
+ extractor.font_size,
+ )
+ try:
+ if extractor.output[-1] != "\n":
+ extractor.output += "\n"
+ if visitor_text is not None:
+ visitor_text(
+ "\n",
+ extractor.memo_cm,
+ extractor.memo_tm,
+ extractor.font_resource,
+ extractor.font_size,
+ )
+ except IndexError:
+ pass
+ try:
+ xobj = resources_dict["/XObject"]
+ if xobj[operands[0]]["/Subtype"] != "/Image": # type: ignore
+ text = self.extract_xform_text(
+ xobj[operands[0]], # type: ignore
+ orientations,
+ space_width,
+ visitor_operand_before,
+ visitor_operand_after,
+ visitor_text,
+ )
+ extractor.output += text
+ if visitor_text is not None:
+ visitor_text(
+ text,
+ extractor.memo_cm,
+ extractor.memo_tm,
+ extractor.font_resource,
+ extractor.font_size,
+ )
+ except Exception as exception:
+ logger_warning(
+ f"Impossible to decode XFormObject {operands[0]}: {exception}",
+ __name__,
+ )
+ finally:
+ extractor.text = ""
+ extractor.memo_cm = extractor.cm_matrix.copy()
+ extractor.memo_tm = extractor.tm_matrix.copy()
+ else:
+ extractor.process_operation(operator, operands)
+ if visitor_operand_after is not None:
+ visitor_operand_after(operator, operands, extractor.cm_matrix, extractor.tm_matrix)
+ extractor.output += extractor.text # just in case
+ if extractor.text != "" and visitor_text is not None:
+ visitor_text(
+ extractor.text,
+ extractor.memo_cm,
+ extractor.memo_tm,
+ extractor.font_resource,
+ extractor.font_size,
+ )
+ return extractor.output
+
+ def _layout_mode_fonts(self) -> dict[str, Font]:
+ """
+ Get fonts formatted for "layout" mode text extraction.
+
+ Returns:
+ Dict[str, Font]: dictionary of Font instances keyed by font name
+
+ """
+ # Font retrieval logic adapted from pypdf.PageObject._extract_text()
+ objr: Any = self
+ fonts: dict[str, Font] = {}
+ while objr is not None:
+ try:
+ resources_dict: Any = objr[PG.RESOURCES]
+ except KeyError:
+ resources_dict = {}
+ if "/Font" in resources_dict and self.pdf is not None:
+ for font_name in resources_dict["/Font"]:
+ fonts[font_name] = Font.from_font_resource(resources_dict["/Font"][font_name])
+ try:
+ objr = objr["/Parent"].get_object()
+ except KeyError:
+ objr = None
+
+ return fonts
+
+ def _layout_mode_text(
+ self,
+ space_vertically: bool = True,
+ scale_weight: float = 1.25,
+ strip_rotated: bool = True,
+ debug_path: Optional[Path] = None,
+ font_height_weight: float = 1,
+ ) -> str:
+ """
+ Get text preserving fidelity to source PDF text layout.
+
+ Args:
+ space_vertically: include blank lines inferred from y distance + font
+ height. Defaults to True.
+ scale_weight: multiplier for string length when calculating weighted
+ average character width. Defaults to 1.25.
+ strip_rotated: Removes text that is rotated w.r.t. to the page from
+ layout mode output. Defaults to True.
+ debug_path (Path | None): if supplied, must target a directory.
+ creates the following files with debug information for layout mode
+ functions if supplied:
+ - fonts.json: output of self._layout_mode_fonts
+ - tjs.json: individual text render ops with corresponding transform matrices
+ - bts.json: text render ops left justified and grouped by BT/ET operators
+ - bt_groups.json: BT/ET operations grouped by rendered y-coord (aka lines)
+ Defaults to None.
+ font_height_weight: multiplier for font height when calculating
+ blank lines. Defaults to 1.
+
+ Returns:
+ str: multiline string containing page text in a fixed width format that
+ closely adheres to the rendered layout in the source pdf.
+
+ """
+ fonts = self._layout_mode_fonts()
+ if debug_path: # pragma: no cover
+ import json # noqa: PLC0415
+
+ debug_path.joinpath("fonts.json").write_text(
+ json.dumps(fonts, indent=2, default=asdict),
+ "utf-8"
+ )
+
+ ops = iter(
+ ContentStream(self["/Contents"].get_object(), self.pdf, "bytes").operations
+ )
+ bt_groups = _layout_mode.text_show_operations(
+ ops, fonts, strip_rotated, debug_path
+ )
+
+ if not bt_groups:
+ return ""
+
+ ty_groups = _layout_mode.y_coordinate_groups(bt_groups, debug_path)
+
+ char_width = _layout_mode.fixed_char_width(bt_groups, scale_weight)
+
+ return _layout_mode.fixed_width_page(ty_groups, char_width, space_vertically, font_height_weight)
+
+ def extract_text(
+ self,
+ *args: Any,
+ orientations: Union[int, tuple[int, ...]] = (0, 90, 180, 270),
+ space_width: float = 200.0,
+ visitor_operand_before: Optional[Callable[[Any, Any, Any, Any], None]] = None,
+ visitor_operand_after: Optional[Callable[[Any, Any, Any, Any], None]] = None,
+ visitor_text: Optional[Callable[[Any, Any, Any, Any, Any], None]] = None,
+ extraction_mode: Literal["plain", "layout"] = "plain",
+ **kwargs: Any,
+ ) -> str:
+ """
+ Locate all text drawing commands, in the order they are provided in the
+ content stream, and extract the text.
+
+ This works well for some PDF files, but poorly for others, depending on
+ the generator used. This will be refined in the future.
+
+ Do not rely on the order of text coming out of this function, as it
+ will change if this function is made more sophisticated.
+
+ Arabic and Hebrew are extracted in the correct order.
+ If required a custom RTL range of characters can be defined;
+ see function set_custom_rtl.
+
+ Additionally you can provide visitor methods to get informed on all
+ operations and all text objects.
+ For example in some PDF files this can be useful to parse tables.
+
+ Args:
+ orientations: list of orientations extract_text will look for
+ default = (0, 90, 180, 270)
+ note: currently only 0 (up),90 (turned left), 180 (upside down),
+ 270 (turned right)
+ Silently ignored in "layout" mode.
+ space_width: force default space width
+ if not extracted from font (default: 200)
+ Silently ignored in "layout" mode.
+ visitor_operand_before: function to be called before processing an operation.
+ It has four arguments: operator, operand-arguments,
+ current transformation matrix and text matrix.
+ Ignored with a warning in "layout" mode.
+ visitor_operand_after: function to be called after processing an operation.
+ It has four arguments: operator, operand-arguments,
+ current transformation matrix and text matrix.
+ Ignored with a warning in "layout" mode.
+ visitor_text: function to be called when extracting some text at some position.
+ It has five arguments: text, current transformation matrix,
+ text matrix, font-dictionary and font-size.
+ The font-dictionary may be None in case of unknown fonts.
+ If not None it may e.g. contain key "/BaseFont" with value "/Arial,Bold".
+ Ignored with a warning in "layout" mode.
+ extraction_mode (Literal["plain", "layout"]): "plain" for legacy functionality,
+ "layout" for experimental layout mode functionality.
+ NOTE: orientations, space_width, and visitor_* parameters are NOT respected
+ in "layout" mode.
+
+ kwargs:
+ layout_mode_space_vertically (bool): include blank lines inferred from
+ y distance + font height. Defaults to True.
+ layout_mode_scale_weight (float): multiplier for string length when calculating
+ weighted average character width. Defaults to 1.25.
+ layout_mode_strip_rotated (bool): layout mode does not support rotated text.
+ Set to False to include rotated text anyway. If rotated text is discovered,
+ layout will be degraded and a warning will result. Defaults to True.
+ layout_mode_debug_path (Path | None): if supplied, must target a directory.
+ creates the following files with debug information for layout mode
+ functions if supplied:
+
+ - fonts.json: output of self._layout_mode_fonts
+ - tjs.json: individual text render ops with corresponding transform matrices
+ - bts.json: text render ops left justified and grouped by BT/ET operators
+ - bt_groups.json: BT/ET operations grouped by rendered y-coord (aka lines)
+ layout_mode_font_height_weight (float): multiplier for font height when calculating
+ blank lines. Defaults to 1.
+
+ Returns:
+ The extracted text
+
+ """
+ if extraction_mode not in ["plain", "layout"]:
+ raise ValueError(f"Invalid text extraction mode '{extraction_mode}'")
+ if extraction_mode == "layout":
+ for visitor in (
+ "visitor_operand_before",
+ "visitor_operand_after",
+ "visitor_text",
+ ):
+ if locals()[visitor]:
+ logger_warning(
+ f"Argument {visitor} is ignored in layout mode",
+ __name__,
+ )
+ return self._layout_mode_text(
+ space_vertically=kwargs.get("layout_mode_space_vertically", True),
+ scale_weight=kwargs.get("layout_mode_scale_weight", 1.25),
+ strip_rotated=kwargs.get("layout_mode_strip_rotated", True),
+ debug_path=kwargs.get("layout_mode_debug_path"),
+ font_height_weight=kwargs.get("layout_mode_font_height_weight", 1)
+ )
+ if len(args) >= 1:
+ if isinstance(args[0], str):
+ if len(args) >= 3:
+ if isinstance(args[2], (tuple, int)):
+ orientations = args[2]
+ else:
+ raise TypeError(f"Invalid positional parameter {args[2]}")
+ if len(args) >= 4:
+ if isinstance(args[3], (float, int)):
+ space_width = args[3]
+ else:
+ raise TypeError(f"Invalid positional parameter {args[3]}")
+ elif isinstance(args[0], (tuple, int)):
+ orientations = args[0]
+ if len(args) >= 2:
+ if isinstance(args[1], (float, int)):
+ space_width = args[1]
+ else:
+ raise TypeError(f"Invalid positional parameter {args[1]}")
+ else:
+ raise TypeError(f"Invalid positional parameter {args[0]}")
+
+ if isinstance(orientations, int):
+ orientations = (orientations,)
+
+ return self._extract_text(
+ self,
+ self.pdf,
+ orientations,
+ space_width,
+ PG.CONTENTS,
+ visitor_operand_before,
+ visitor_operand_after,
+ visitor_text,
+ )
+
+ def extract_xform_text(
+ self,
+ xform: EncodedStreamObject,
+ orientations: tuple[int, ...] = (0, 90, 270, 360),
+ space_width: float = 200.0,
+ visitor_operand_before: Optional[Callable[[Any, Any, Any, Any], None]] = None,
+ visitor_operand_after: Optional[Callable[[Any, Any, Any, Any], None]] = None,
+ visitor_text: Optional[Callable[[Any, Any, Any, Any, Any], None]] = None,
+ ) -> str:
+ """
+ Extract text from an XObject.
+
+ Args:
+ xform:
+ orientations:
+ space_width: force default space width (if not extracted from font (default 200)
+ visitor_operand_before:
+ visitor_operand_after:
+ visitor_text:
+
+ Returns:
+ The extracted text
+
+ """
+ return self._extract_text(
+ xform,
+ self.pdf,
+ orientations,
+ space_width,
+ None,
+ visitor_operand_before,
+ visitor_operand_after,
+ visitor_text,
+ )
+
+ def _get_fonts(self) -> tuple[set[str], set[str]]:
+ """
+ Get the names of embedded fonts and unembedded fonts.
+
+ Returns:
+ A tuple (set of embedded fonts, set of unembedded fonts)
+
+ """
+ obj = self.get_object()
+ assert isinstance(obj, DictionaryObject)
+ fonts: set[str] = set()
+ embedded: set[str] = set()
+ fonts, embedded = _get_fonts_walk(obj, fonts, embedded)
+ unembedded = fonts - embedded
+ return embedded, unembedded
+
+ mediabox = _create_rectangle_accessor(PG.MEDIABOX, ())
+ """A :class:`RectangleObject`, expressed in
+ default user space units, defining the boundaries of the physical medium on
+ which the page is intended to be displayed or printed."""
+
+ cropbox = _create_rectangle_accessor("/CropBox", (PG.MEDIABOX,))
+ """
+ A :class:`RectangleObject`, expressed in
+ default user space units, defining the visible region of default user
+ space.
+
+ When the page is displayed or printed, its contents are to be clipped
+ (cropped) to this rectangle and then imposed on the output medium in some
+ implementation-defined manner. Default value: same as
+ :attr:`mediabox`.
+ """
+
+ bleedbox = _create_rectangle_accessor("/BleedBox", ("/CropBox", PG.MEDIABOX))
+ """A :class:`RectangleObject`, expressed in
+ default user space units, defining the region to which the contents of the
+ page should be clipped when output in a production environment."""
+
+ trimbox = _create_rectangle_accessor("/TrimBox", ("/CropBox", PG.MEDIABOX))
+ """A :class:`RectangleObject`, expressed in
+ default user space units, defining the intended dimensions of the finished
+ page after trimming."""
+
+ artbox = _create_rectangle_accessor("/ArtBox", ("/CropBox", PG.MEDIABOX))
+ """A :class:`RectangleObject`, expressed in
+ default user space units, defining the extent of the page's meaningful
+ content as intended by the page's creator."""
+
+ @property
+ def annotations(self) -> Optional[ArrayObject]:
+ if "/Annots" not in self:
+ return None
+ return cast(ArrayObject, self["/Annots"])
+
+ @annotations.setter
+ def annotations(self, value: Optional[ArrayObject]) -> None:
+ """
+ Set the annotations array of the page.
+
+ Typically you do not want to set this value, but append to it.
+ If you append to it, remember to add the object first to the writer
+ and only add the indirect object.
+ """
+ if value is None:
+ if "/Annots" not in self:
+ return
+ del self[NameObject("/Annots")]
+ else:
+ self[NameObject("/Annots")] = value
+
+
+class _VirtualList(Sequence[PageObject]):
+ def __init__(
+ self,
+ length_function: Callable[[], int],
+ get_function: Callable[[int], PageObject],
+ ) -> None:
+ self.length_function = length_function
+ self.get_function = get_function
+ self.current = -1
+
+ def __len__(self) -> int:
+ return self.length_function()
+
+ @overload
+ def __getitem__(self, index: int) -> PageObject:
+ ...
+
+ @overload
+ def __getitem__(self, index: slice) -> Sequence[PageObject]:
+ ...
+
+ def __getitem__(
+ self, index: Union[int, slice]
+ ) -> Union[PageObject, Sequence[PageObject]]:
+ if isinstance(index, slice):
+ indices = range(*index.indices(len(self)))
+ cls = type(self)
+ return cls(indices.__len__, lambda idx: self[indices[idx]])
+ if not isinstance(index, int):
+ raise TypeError("Sequence indices must be integers")
+ len_self = len(self)
+ if index < 0:
+ # support negative indexes
+ index += len_self
+ if not (0 <= index < len_self):
+ raise IndexError("Sequence index out of range")
+ return self.get_function(index)
+
+ def __delitem__(self, index: Union[int, slice]) -> None:
+ if isinstance(index, slice):
+ r = list(range(*index.indices(len(self))))
+ # pages have to be deleted from last to first
+ r.sort()
+ r.reverse()
+ for p in r:
+ del self[p] # recursive call
+ return
+ if not isinstance(index, int):
+ raise TypeError("Index must be integers")
+ len_self = len(self)
+ if index < 0:
+ # support negative indexes
+ index += len_self
+ if not (0 <= index < len_self):
+ raise IndexError("Index out of range")
+ ind = self[index].indirect_reference
+ assert ind is not None
+ parent: Optional[PdfObject] = cast(DictionaryObject, ind.get_object()).get(
+ "/Parent", None
+ )
+ first = True
+ while parent is not None:
+ parent = cast(DictionaryObject, parent.get_object())
+ try:
+ i = cast(ArrayObject, parent["/Kids"]).index(ind)
+ del cast(ArrayObject, parent["/Kids"])[i]
+ first = False
+ try:
+ assert ind is not None
+ del ind.pdf.flattened_pages[index] # case of page in a Reader
+ except Exception: # pragma: no cover
+ pass
+ if "/Count" in parent:
+ parent[NameObject("/Count")] = NumberObject(
+ cast(int, parent["/Count"]) - 1
+ )
+ if len(cast(ArrayObject, parent["/Kids"])) == 0:
+ # No more objects in this part of this subtree
+ ind = parent.indirect_reference
+ parent = parent.get("/Parent", None)
+ except ValueError: # from index
+ if first:
+ raise PdfReadError(f"Page not found in page tree: {ind}")
+ break
+
+ def __iter__(self) -> Iterator[PageObject]:
+ for i in range(len(self)):
+ yield self[i]
+
+ def __str__(self) -> str:
+ p = [f"PageObject({i})" for i in range(self.length_function())]
+ return f"[{', '.join(p)}]"
+
+
+def _get_fonts_walk(
+ obj: DictionaryObject,
+ fnt: set[str],
+ emb: set[str],
+) -> tuple[set[str], set[str]]:
+ """
+ Get the set of all fonts and all embedded fonts.
+
+ Args:
+ obj: Page resources dictionary
+ fnt: font
+ emb: embedded fonts
+
+ Returns:
+ A tuple (fnt, emb)
+
+ If there is a key called 'BaseFont', that is a font that is used in the document.
+ If there is a key called 'FontName' and another key in the same dictionary object
+ that is called 'FontFilex' (where x is null, 2, or 3), then that fontname is
+ embedded.
+
+ We create and add to two sets, fnt = fonts used and emb = fonts embedded.
+
+ """
+ fontkeys = ("/FontFile", "/FontFile2", "/FontFile3")
+
+ def process_font(f: DictionaryObject) -> None:
+ nonlocal fnt, emb
+ f = cast(DictionaryObject, f.get_object()) # to be sure
+ if "/BaseFont" in f:
+ fnt.add(cast(str, f["/BaseFont"]))
+
+ if (
+ ("/CharProcs" in f)
+ or (
+ "/FontDescriptor" in f
+ and any(
+ x in cast(DictionaryObject, f["/FontDescriptor"]) for x in fontkeys
+ )
+ )
+ or (
+ "/DescendantFonts" in f
+ and "/FontDescriptor"
+ in cast(
+ DictionaryObject,
+ cast(ArrayObject, f["/DescendantFonts"])[0].get_object(),
+ )
+ and any(
+ x
+ in cast(
+ DictionaryObject,
+ cast(
+ DictionaryObject,
+ cast(ArrayObject, f["/DescendantFonts"])[0].get_object(),
+ )["/FontDescriptor"],
+ )
+ for x in fontkeys
+ )
+ )
+ ):
+ # the list comprehension ensures there is FontFile
+ try:
+ emb.add(cast(str, f["/BaseFont"]))
+ except KeyError:
+ emb.add("(" + cast(str, f["/Subtype"]) + ")")
+
+ if "/DR" in obj and "/Font" in cast(DictionaryObject, obj["/DR"]):
+ for f in cast(DictionaryObject, cast(DictionaryObject, obj["/DR"])["/Font"]):
+ process_font(f)
+ if "/Resources" in obj:
+ if "/Font" in cast(DictionaryObject, obj["/Resources"]):
+ for f in cast(
+ DictionaryObject, cast(DictionaryObject, obj["/Resources"])["/Font"]
+ ).values():
+ process_font(f)
+ if "/XObject" in cast(DictionaryObject, obj["/Resources"]):
+ for x in cast(
+ DictionaryObject, cast(DictionaryObject, obj["/Resources"])["/XObject"]
+ ).values():
+ _get_fonts_walk(cast(DictionaryObject, x.get_object()), fnt, emb)
+ if "/Annots" in obj:
+ for a in cast(ArrayObject, obj["/Annots"]):
+ _get_fonts_walk(cast(DictionaryObject, a.get_object()), fnt, emb)
+ if "/AP" in obj:
+ if (
+ cast(DictionaryObject, cast(DictionaryObject, obj["/AP"])["/N"]).get(
+ "/Type"
+ )
+ == "/XObject"
+ ):
+ _get_fonts_walk(
+ cast(DictionaryObject, cast(DictionaryObject, obj["/AP"])["/N"]),
+ fnt,
+ emb,
+ )
+ else:
+ for a in cast(DictionaryObject, cast(DictionaryObject, obj["/AP"])["/N"]):
+ _get_fonts_walk(cast(DictionaryObject, a), fnt, emb)
+ return fnt, emb # return the sets for each page
diff --git a/venv/lib/python3.12/site-packages/pypdf/_page_labels.py b/venv/lib/python3.12/site-packages/pypdf/_page_labels.py
new file mode 100644
index 0000000..4c20da5
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_page_labels.py
@@ -0,0 +1,289 @@
+"""
+Page labels are shown by PDF viewers as "the page number".
+
+A page has a numeric index, starting at 0. Additionally, the page
+has a label. In the most simple case:
+
+ label = index + 1
+
+However, the title page and the table of contents might have Roman numerals as
+page labels. This makes things more complicated.
+
+Example 1
+---------
+
+>>> reader.root_object["/PageLabels"]["/Nums"]
+[0, IndirectObject(18, 0, 139929798197504),
+ 8, IndirectObject(19, 0, 139929798197504)]
+>>> reader.get_object(reader.root_object["/PageLabels"]["/Nums"][1])
+{'/S': '/r'}
+>>> reader.get_object(reader.root_object["/PageLabels"]["/Nums"][3])
+{'/S': '/D'}
+
+Example 2
+---------
+The following is a document with pages labeled
+i, ii, iii, iv, 1, 2, 3, A-8, A-9, ...
+
+1 0 obj
+ << /Type /Catalog
+ /PageLabels << /Nums [
+ 0 << /S /r >>
+ 4 << /S /D >>
+ 7 << /S /D
+ /P ( A- )
+ /St 8
+ >>
+ % A number tree containing
+ % three page label dictionaries
+ ]
+ >>
+ ...
+ >>
+endobj
+
+
+§12.4.2 PDF Specification 1.7 and 2.0
+=====================================
+
+Entries in a page label dictionary
+----------------------------------
+The /S key:
+D Decimal Arabic numerals
+R Uppercase Roman numerals
+r Lowercase Roman numerals
+A Uppercase letters (A to Z for the first 26 pages,
+ AA to ZZ for the next 26, and so on)
+a Lowercase letters (a to z for the first 26 pages,
+ aa to zz for the next 26, and so on)
+"""
+
+from collections.abc import Iterator
+from typing import Optional, cast
+
+from ._protocols import PdfCommonDocProtocol
+from ._utils import logger_warning
+from .generic import (
+ ArrayObject,
+ DictionaryObject,
+ NullObject,
+ NumberObject,
+ is_null_or_none,
+)
+
+
+def number2uppercase_roman_numeral(num: int) -> str:
+ roman = [
+ (1000, "M"),
+ (900, "CM"),
+ (500, "D"),
+ (400, "CD"),
+ (100, "C"),
+ (90, "XC"),
+ (50, "L"),
+ (40, "XL"),
+ (10, "X"),
+ (9, "IX"),
+ (5, "V"),
+ (4, "IV"),
+ (1, "I"),
+ ]
+
+ def roman_num(num: int) -> Iterator[str]:
+ for decimal, roman_repr in roman:
+ x, _ = divmod(num, decimal)
+ yield roman_repr * x
+ num -= decimal * x
+ if num <= 0:
+ break
+
+ return "".join(list(roman_num(num)))
+
+
+def number2lowercase_roman_numeral(number: int) -> str:
+ return number2uppercase_roman_numeral(number).lower()
+
+
+def number2uppercase_letter(number: int) -> str:
+ if number <= 0:
+ raise ValueError("Expecting a positive number")
+ alphabet = [chr(i) for i in range(ord("A"), ord("Z") + 1)]
+ rep = ""
+ while number > 0:
+ remainder = number % 26
+ if remainder == 0:
+ remainder = 26
+ rep = alphabet[remainder - 1] + rep
+ # update
+ number -= remainder
+ number = number // 26
+ return rep
+
+
+def number2lowercase_letter(number: int) -> str:
+ return number2uppercase_letter(number).lower()
+
+
+def get_label_from_nums(dictionary_object: DictionaryObject, index: int) -> str:
+ # [Nums] shall be an array of the form
+ # [ key_1 value_1 key_2 value_2 ... key_n value_n ]
+ # where each key_i is an integer and the corresponding
+ # value_i shall be the object associated with that key.
+ # The keys shall be sorted in numerical order,
+ # analogously to the arrangement of keys in a name tree
+ # as described in 7.9.6, "Name Trees."
+ nums = cast(ArrayObject, dictionary_object["/Nums"])
+ i = 0
+ value = None
+ start_index = 0
+ while i < len(nums):
+ start_index = nums[i]
+ value = nums[i + 1].get_object()
+ if i + 2 == len(nums):
+ break
+ if nums[i + 2] > index:
+ break
+ i += 2
+ m = {
+ None: lambda _: "",
+ "/D": lambda n: str(n),
+ "/R": number2uppercase_roman_numeral,
+ "/r": number2lowercase_roman_numeral,
+ "/A": number2uppercase_letter,
+ "/a": number2lowercase_letter,
+ }
+ # if /Nums array is not following the specification or if /Nums is empty
+ if not isinstance(value, dict):
+ return str(index + 1) # Fallback
+ start = value.get("/St", 1)
+ prefix = value.get("/P", "")
+ return prefix + m[value.get("/S")](index - start_index + start)
+
+
+def index2label(reader: PdfCommonDocProtocol, index: int) -> str:
+ """
+ See 7.9.7 "Number Trees".
+
+ Args:
+ reader: The PdfReader
+ index: The index of the page
+
+ Returns:
+ The label of the page, e.g. "iv" or "4".
+
+ """
+ root = cast(DictionaryObject, reader.root_object)
+ if "/PageLabels" not in root:
+ return str(index + 1) # Fallback
+ number_tree = cast(DictionaryObject, root["/PageLabels"].get_object())
+ if "/Nums" in number_tree:
+ return get_label_from_nums(number_tree, index)
+ if "/Kids" in number_tree and not isinstance(number_tree["/Kids"], NullObject):
+ # number_tree = {'/Kids': [IndirectObject(7333, 0, 140132998195856), ...]}
+ # Limit maximum depth.
+ level = 0
+ while level < 100:
+ kids = cast(list[DictionaryObject], number_tree["/Kids"])
+ for kid in kids:
+ # kid = {'/Limits': [0, 63], '/Nums': [0, {'/P': 'C1'}, ...]}
+ limits = cast(list[int], kid["/Limits"])
+ if limits[0] <= index <= limits[1]:
+ if not is_null_or_none(kid.get("/Kids", None)):
+ # Recursive definition.
+ level += 1
+ if level == 100: # pragma: no cover
+ raise NotImplementedError(
+ "Too deep nesting is not supported."
+ )
+ number_tree = kid
+ # Exit the inner `for` loop and continue at the next level with the
+ # next iteration of the `while` loop.
+ break
+ return get_label_from_nums(kid, index)
+ else:
+ # When there are no kids, make sure to exit the `while` loop directly
+ # and continue with the fallback.
+ break
+
+ logger_warning(f"Could not reliably determine page label for {index}.", __name__)
+ return str(index + 1) # Fallback if neither /Nums nor /Kids is in the number_tree
+
+
+def nums_insert(
+ key: NumberObject,
+ value: DictionaryObject,
+ nums: ArrayObject,
+) -> None:
+ """
+ Insert a key, value pair in a Nums array.
+
+ See 7.9.7 "Number Trees".
+
+ Args:
+ key: number key of the entry
+ value: value of the entry
+ nums: Nums array to modify
+
+ """
+ if len(nums) % 2 != 0:
+ raise ValueError("A nums like array must have an even number of elements")
+
+ i = len(nums)
+ while i != 0 and key <= nums[i - 2]:
+ i = i - 2
+
+ if i < len(nums) and key == nums[i]:
+ nums[i + 1] = value
+ else:
+ nums.insert(i, key)
+ nums.insert(i + 1, value)
+
+
+def nums_clear_range(
+ key: NumberObject,
+ page_index_to: int,
+ nums: ArrayObject,
+) -> None:
+ """
+ Remove all entries in a number tree in a range after an entry.
+
+ See 7.9.7 "Number Trees".
+
+ Args:
+ key: number key of the entry before the range
+ page_index_to: The page index of the upper limit of the range
+ nums: Nums array to modify
+
+ """
+ if len(nums) % 2 != 0:
+ raise ValueError("A nums like array must have an even number of elements")
+ if page_index_to < key:
+ raise ValueError("page_index_to must be greater or equal than key")
+
+ i = nums.index(key) + 2
+ while i < len(nums) and nums[i] <= page_index_to:
+ nums.pop(i)
+ nums.pop(i)
+
+
+def nums_next(
+ key: NumberObject,
+ nums: ArrayObject,
+) -> tuple[Optional[NumberObject], Optional[DictionaryObject]]:
+ """
+ Return the (key, value) pair of the entry after the given one.
+
+ See 7.9.7 "Number Trees".
+
+ Args:
+ key: number key of the entry
+ nums: Nums array
+
+ """
+ if len(nums) % 2 != 0:
+ raise ValueError("A nums like array must have an even number of elements")
+
+ i = nums.index(key) + 2
+ if i < len(nums):
+ return (nums[i], nums[i + 1])
+ return (None, None)
diff --git a/venv/lib/python3.12/site-packages/pypdf/_protocols.py b/venv/lib/python3.12/site-packages/pypdf/_protocols.py
new file mode 100644
index 0000000..ac24abb
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_protocols.py
@@ -0,0 +1,86 @@
+"""Helpers for working with PDF types."""
+
+from abc import abstractmethod
+from pathlib import Path
+from typing import IO, Any, Optional, Protocol, Union
+
+from ._utils import StrByteType, StreamType
+
+
+class PdfObjectProtocol(Protocol):
+ indirect_reference: Any
+
+ def clone(
+ self,
+ pdf_dest: Any,
+ force_duplicate: bool = False,
+ ignore_fields: Union[tuple[str, ...], list[str], None] = (),
+ ) -> Any:
+ ... # pragma: no cover
+
+ def _reference_clone(self, clone: Any, pdf_dest: Any) -> Any:
+ ... # pragma: no cover
+
+ def get_object(self) -> Optional["PdfObjectProtocol"]:
+ ... # pragma: no cover
+
+ def hash_value(self) -> bytes:
+ ... # pragma: no cover
+
+ def write_to_stream(
+ self, stream: StreamType, encryption_key: Union[None, str, bytes] = None
+ ) -> None:
+ ... # pragma: no cover
+
+
+class XmpInformationProtocol(PdfObjectProtocol):
+ pass
+
+
+class PdfCommonDocProtocol(Protocol):
+ @property
+ def pdf_header(self) -> str:
+ ... # pragma: no cover
+
+ @property
+ def pages(self) -> list[Any]:
+ ... # pragma: no cover
+
+ @property
+ def root_object(self) -> PdfObjectProtocol:
+ ... # pragma: no cover
+
+ def get_object(self, indirect_reference: Any) -> Optional[PdfObjectProtocol]:
+ ... # pragma: no cover
+
+ @property
+ def strict(self) -> bool:
+ ... # pragma: no cover
+
+
+class PdfReaderProtocol(PdfCommonDocProtocol, Protocol):
+ @property
+ @abstractmethod
+ def xref(self) -> dict[int, dict[int, Any]]:
+ ... # pragma: no cover
+
+ @property
+ @abstractmethod
+ def trailer(self) -> dict[str, Any]:
+ ... # pragma: no cover
+
+
+class PdfWriterProtocol(PdfCommonDocProtocol, Protocol):
+ _objects: list[Any]
+ _id_translated: dict[int, dict[int, int]]
+
+ incremental: bool
+ _reader: Any # PdfReader
+
+ @abstractmethod
+ def write(self, stream: Union[Path, StrByteType]) -> tuple[bool, IO[Any]]:
+ ... # pragma: no cover
+
+ @abstractmethod
+ def _add_object(self, obj: Any) -> Any:
+ ... # pragma: no cover
diff --git a/venv/lib/python3.12/site-packages/pypdf/_reader.py b/venv/lib/python3.12/site-packages/pypdf/_reader.py
new file mode 100644
index 0000000..efce5c4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_reader.py
@@ -0,0 +1,1352 @@
+# Copyright (c) 2006, Mathieu Fenniak
+# Copyright (c) 2007, Ashish Kulkarni
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+
+import os
+import re
+import sys
+from collections.abc import Iterable
+from io import BytesIO, UnsupportedOperation
+from pathlib import Path
+from types import TracebackType
+from typing import (
+ TYPE_CHECKING,
+ Any,
+ Callable,
+ Optional,
+ Union,
+ cast,
+)
+
+from ._doc_common import PdfDocCommon, convert_to_int
+from ._encryption import Encryption, PasswordType
+from ._utils import (
+ WHITESPACES_AS_BYTES,
+ StrByteType,
+ StreamType,
+ logger_warning,
+ read_non_whitespace,
+ read_previous_line,
+ read_until_whitespace,
+ skip_over_comment,
+ skip_over_whitespace,
+)
+from .constants import TrailerKeys as TK
+from .errors import (
+ EmptyFileError,
+ FileNotDecryptedError,
+ LimitReachedError,
+ PdfReadError,
+ PdfStreamError,
+ WrongPasswordError,
+)
+from .generic import (
+ ArrayObject,
+ ContentStream,
+ DecodedStreamObject,
+ DictionaryObject,
+ EncodedStreamObject,
+ IndirectObject,
+ NameObject,
+ NullObject,
+ NumberObject,
+ PdfObject,
+ StreamObject,
+ TextStringObject,
+ is_null_or_none,
+ read_object,
+)
+from .xmp import XmpInformation
+
+if TYPE_CHECKING:
+ from ._page import PageObject
+
+
+class PdfReader(PdfDocCommon):
+ """
+ Initialize a PdfReader object.
+
+ This operation can take some time, as the PDF stream's cross-reference
+ tables are read into memory.
+
+ Args:
+ stream: A File object or an object that supports the standard read
+ and seek methods similar to a File object. Could also be a
+ string representing a path to a PDF file.
+ strict: Determines whether user should be warned of all
+ problems and also causes some correctable problems to be fatal.
+ Defaults to ``False``.
+ password: Decrypt PDF file at initialization. If the
+ password is None, the file will not be decrypted.
+ Defaults to ``None``.
+ root_object_recovery_limit: The maximum number of objects to query
+ for recovering the Root object in non-strict mode. To disable
+ this security measure, pass ``None``.
+
+ """
+
+ def __init__(
+ self,
+ stream: Union[StrByteType, Path],
+ strict: bool = False,
+ password: Union[None, str, bytes] = None,
+ *,
+ root_object_recovery_limit: Optional[int] = 10_000,
+ ) -> None:
+ self.strict = strict
+ self.flattened_pages: Optional[list[PageObject]] = None
+
+ #: Storage of parsed PDF objects.
+ self.resolved_objects: dict[tuple[Any, Any], Optional[PdfObject]] = {}
+
+ self._startxref: int = 0
+ self.xref_index = 0
+ self.xref: dict[int, dict[Any, Any]] = {}
+ self.xref_free_entry: dict[int, dict[Any, Any]] = {}
+ self.xref_objStm: dict[int, tuple[Any, Any]] = {}
+ self.trailer = DictionaryObject()
+
+ # Security parameters.
+ self._root_object_recovery_limit = (
+ root_object_recovery_limit if isinstance(root_object_recovery_limit, int) else sys.maxsize
+ )
+
+ # Map page indirect_reference number to page number
+ self._page_id2num: Optional[dict[Any, Any]] = None
+
+ self._validated_root: Optional[DictionaryObject] = None
+
+ self._initialize_stream(stream)
+ self._known_objects: set[tuple[int, int]] = set()
+
+ self._override_encryption = False
+ self._encryption: Optional[Encryption] = None
+ if self.is_encrypted:
+ self._handle_encryption(password)
+ elif password is not None:
+ raise PdfReadError("Not an encrypted file")
+
+ def _initialize_stream(self, stream: Union[StrByteType, Path]) -> None:
+ if hasattr(stream, "mode") and "b" not in stream.mode:
+ logger_warning(
+ "PdfReader stream/file object is not in binary mode. "
+ "It may not be read correctly.",
+ __name__,
+ )
+ self._stream_opened = False
+ if isinstance(stream, (str, Path)):
+ with open(stream, "rb") as fh:
+ stream = BytesIO(fh.read())
+ self._stream_opened = True
+ self.read(stream)
+ self.stream = stream
+
+ def _handle_encryption(self, password: Optional[Union[str, bytes]]) -> None:
+ self._override_encryption = True
+ # Some documents may not have a /ID, use two empty
+ # byte strings instead. Solves
+ # https://github.com/py-pdf/pypdf/issues/608
+ id_entry = self.trailer.get(TK.ID)
+ id1_entry = id_entry[0].get_object().original_bytes if id_entry else b""
+ encrypt_entry = cast(DictionaryObject, self.trailer[TK.ENCRYPT].get_object())
+ self._encryption = Encryption.read(encrypt_entry, id1_entry)
+
+ # try empty password if no password provided
+ pwd = password if password is not None else b""
+ if (
+ self._encryption.verify(pwd) == PasswordType.NOT_DECRYPTED
+ and password is not None
+ ):
+ # raise if password provided
+ raise WrongPasswordError("Wrong password")
+ self._override_encryption = False
+
+ def __enter__(self) -> "PdfReader":
+ return self
+
+ def __exit__(
+ self,
+ exc_type: Optional[type[BaseException]],
+ exc_val: Optional[BaseException],
+ exc_tb: Optional[TracebackType],
+ ) -> None:
+ self.close()
+
+ def close(self) -> None:
+ """Close the stream if opened in __init__ and clear memory."""
+ if self._stream_opened:
+ self.stream.close()
+ self.flattened_pages = []
+ self.resolved_objects = {}
+ self.trailer = DictionaryObject()
+ self.xref = {}
+ self.xref_free_entry = {}
+ self.xref_objStm = {}
+
+ @property
+ def root_object(self) -> DictionaryObject:
+ """Provide access to "/Root". Standardized with PdfWriter."""
+ if self._validated_root:
+ return self._validated_root
+ root = self.trailer.get(TK.ROOT)
+ if is_null_or_none(root):
+ logger_warning('Cannot find "/Root" key in trailer', __name__)
+ elif (
+ cast(DictionaryObject, cast(PdfObject, root).get_object()).get("/Type")
+ == "/Catalog"
+ ):
+ self._validated_root = cast(
+ DictionaryObject, cast(PdfObject, root).get_object()
+ )
+ else:
+ logger_warning("Invalid Root object in trailer", __name__)
+ if self._validated_root is None:
+ logger_warning('Searching object with "/Catalog" key', __name__)
+ number_of_objects = cast(int, self.trailer.get("/Size", 0))
+ for i in range(number_of_objects):
+ if i >= self._root_object_recovery_limit:
+ raise LimitReachedError("Maximum Root object recovery limit reached.")
+ try:
+ obj = self.get_object(i + 1)
+ except Exception: # to be sure to capture all errors
+ obj = None
+ if isinstance(obj, DictionaryObject) and obj.get("/Type") == "/Catalog":
+ self._validated_root = obj
+ logger_warning(f"Root found at {obj.indirect_reference!r}", __name__)
+ break
+ if self._validated_root is None:
+ if not is_null_or_none(root) and "/Pages" in cast(DictionaryObject, cast(PdfObject, root).get_object()):
+ logger_warning(
+ f"Possible root found at {cast(PdfObject, root).indirect_reference!r}, but missing /Catalog key",
+ __name__
+ )
+ self._validated_root = cast(
+ DictionaryObject, cast(PdfObject, root).get_object()
+ )
+ else:
+ raise PdfReadError("Cannot find Root object in pdf")
+ return self._validated_root
+
+ @property
+ def _info(self) -> Optional[DictionaryObject]:
+ """
+ Provide access to "/Info". Standardized with PdfWriter.
+
+ Returns:
+ /Info Dictionary; None if the entry does not exist
+
+ """
+ info = self.trailer.get(TK.INFO, None)
+ if is_null_or_none(info):
+ return None
+ assert info is not None, "mypy"
+ info = info.get_object()
+ if not isinstance(info, DictionaryObject):
+ raise PdfReadError(
+ "Trailer not found or does not point to a document information dictionary"
+ )
+ return info
+
+ @property
+ def _ID(self) -> Optional[ArrayObject]:
+ """
+ Provide access to "/ID". Standardized with PdfWriter.
+
+ Returns:
+ /ID array; None if the entry does not exist
+
+ """
+ id = self.trailer.get(TK.ID, None)
+ if is_null_or_none(id):
+ return None
+ assert id is not None, "mypy"
+ return cast(ArrayObject, id.get_object())
+
+ @property
+ def pdf_header(self) -> str:
+ """
+ The first 8 bytes of the file.
+
+ This is typically something like ``'%PDF-1.6'`` and can be used to
+ detect if the file is actually a PDF file and which version it is.
+ """
+ # TODO: Make this return a bytes object for consistency
+ # but that needs a deprecation
+ loc = self.stream.tell()
+ self.stream.seek(0, 0)
+ pdf_file_version = self.stream.read(8).decode("utf-8", "backslashreplace")
+ self.stream.seek(loc, 0) # return to where it was
+ return pdf_file_version
+
+ @property
+ def xmp_metadata(self) -> Optional[XmpInformation]:
+ """XMP (Extensible Metadata Platform) data."""
+ try:
+ self._override_encryption = True
+ return cast(XmpInformation, self.root_object.xmp_metadata)
+ finally:
+ self._override_encryption = False
+
+ def _get_page_number_by_indirect(
+ self, indirect_reference: Union[None, int, NullObject, IndirectObject]
+ ) -> Optional[int]:
+ """
+ Retrieve the page number from an indirect reference.
+
+ Args:
+ indirect_reference: The indirect reference to locate.
+
+ Returns:
+ Page number or None.
+
+ """
+ if self._page_id2num is None:
+ self._page_id2num = {
+ x.indirect_reference.idnum: i for i, x in enumerate(self.pages) # type: ignore
+ }
+
+ if is_null_or_none(indirect_reference):
+ return None
+ assert isinstance(indirect_reference, (int, IndirectObject)), "mypy"
+ if isinstance(indirect_reference, int):
+ idnum = indirect_reference
+ else:
+ idnum = indirect_reference.idnum
+ assert self._page_id2num is not None, "hint for mypy"
+ return self._page_id2num.get(idnum, None)
+
+ def _get_object_from_stream(
+ self, indirect_reference: IndirectObject
+ ) -> Union[int, PdfObject, str]:
+ # indirect reference to object in object stream
+ # read the entire object stream into memory
+ stmnum, idx = self.xref_objStm[indirect_reference.idnum]
+ obj_stm: EncodedStreamObject = IndirectObject(stmnum, 0, self).get_object() # type: ignore
+ # This is an xref to a stream, so its type better be a stream
+ assert cast(str, obj_stm["/Type"]) == "/ObjStm"
+ stream_data = BytesIO(obj_stm.get_data())
+ for i in range(obj_stm["/N"]): # type: ignore
+ read_non_whitespace(stream_data)
+ stream_data.seek(-1, 1)
+ objnum = NumberObject.read_from_stream(stream_data)
+ read_non_whitespace(stream_data)
+ stream_data.seek(-1, 1)
+ offset = NumberObject.read_from_stream(stream_data)
+ read_non_whitespace(stream_data)
+ stream_data.seek(-1, 1)
+ if objnum != indirect_reference.idnum:
+ # We're only interested in one object
+ continue
+ if self.strict and idx != i:
+ raise PdfReadError("Object is in wrong index.")
+ stream_data.seek(int(obj_stm["/First"] + offset), 0) # type: ignore
+
+ # To cope with case where the 'pointer' is on a white space
+ read_non_whitespace(stream_data)
+ stream_data.seek(-1, 1)
+
+ try:
+ obj = read_object(stream_data, self)
+ except PdfStreamError as exc:
+ # Stream object cannot be read. Normally, a critical error, but
+ # Adobe Reader doesn't complain, so continue (in strict mode?)
+ logger_warning(
+ f"Invalid stream (index {i}) within object "
+ f"{indirect_reference.idnum} {indirect_reference.generation}: "
+ f"{exc}",
+ __name__,
+ )
+
+ if self.strict: # pragma: no cover
+ raise PdfReadError(
+ f"Cannot read object stream: {exc}"
+ ) # pragma: no cover
+ # Replace with null. Hopefully it's nothing important.
+ obj = NullObject() # pragma: no cover
+ return obj
+
+ if self.strict: # pragma: no cover
+ raise PdfReadError(
+ "This is a fatal error in strict mode."
+ ) # pragma: no cover
+ return NullObject() # pragma: no cover
+
+ def get_object(
+ self, indirect_reference: Union[int, IndirectObject]
+ ) -> Optional[PdfObject]:
+ if isinstance(indirect_reference, int):
+ indirect_reference = IndirectObject(indirect_reference, 0, self)
+ retval = self.cache_get_indirect_object(
+ indirect_reference.generation, indirect_reference.idnum
+ )
+ if retval is not None:
+ return retval
+ if (
+ indirect_reference.generation == 0
+ and indirect_reference.idnum in self.xref_objStm
+ ):
+ retval = self._get_object_from_stream(indirect_reference) # type: ignore
+ elif (
+ indirect_reference.generation in self.xref
+ and indirect_reference.idnum in self.xref[indirect_reference.generation]
+ ):
+ if self.xref_free_entry.get(indirect_reference.generation, {}).get(
+ indirect_reference.idnum, False
+ ):
+ return NullObject()
+ start = self.xref[indirect_reference.generation][indirect_reference.idnum]
+ self.stream.seek(start, 0)
+ try:
+ idnum, generation = self.read_object_header(self.stream)
+ if (
+ idnum != indirect_reference.idnum
+ or generation != indirect_reference.generation
+ ):
+ raise PdfReadError("Not matching, we parse the file for it")
+ except Exception:
+ if hasattr(self.stream, "getbuffer"):
+ buf = bytes(self.stream.getbuffer())
+ else:
+ p = self.stream.tell()
+ self.stream.seek(0, 0)
+ buf = self.stream.read(-1)
+ self.stream.seek(p, 0)
+ m = re.search(
+ rf"\s{indirect_reference.idnum}\s+{indirect_reference.generation}\s+obj".encode(),
+ buf,
+ )
+ if m is not None:
+ logger_warning(
+ f"Object ID {indirect_reference.idnum},{indirect_reference.generation} ref repaired",
+ __name__,
+ )
+ self.xref[indirect_reference.generation][
+ indirect_reference.idnum
+ ] = (m.start(0) + 1)
+ self.stream.seek(m.start(0) + 1)
+ idnum, generation = self.read_object_header(self.stream)
+ else:
+ idnum = -1
+ generation = -1 # exception will be raised below
+ if idnum != indirect_reference.idnum and self.xref_index:
+ # xref table probably had bad indexes due to not being zero-indexed
+ if self.strict:
+ raise PdfReadError(
+ f"Expected object ID ({indirect_reference.idnum} {indirect_reference.generation}) "
+ f"does not match actual ({idnum} {generation}); "
+ "xref table not zero-indexed."
+ )
+ # xref table is corrected in non-strict mode
+ elif idnum != indirect_reference.idnum and self.strict:
+ # some other problem
+ raise PdfReadError(
+ f"Expected object ID ({indirect_reference.idnum} {indirect_reference.generation}) "
+ f"does not match actual ({idnum} {generation})."
+ )
+ if self.strict:
+ assert generation == indirect_reference.generation
+
+ current_object = (indirect_reference.idnum, indirect_reference.generation)
+ if current_object in self._known_objects:
+ raise PdfReadError(f"Detected loop with self reference for {indirect_reference!r}.")
+ self._known_objects.add(current_object)
+ retval = read_object(self.stream, self) # type: ignore
+ self._known_objects.remove(current_object)
+
+ # override encryption is used for the /Encrypt dictionary
+ if not self._override_encryption and self._encryption is not None:
+ # if we don't have the encryption key:
+ if not self._encryption.is_decrypted():
+ raise FileNotDecryptedError("File has not been decrypted")
+ # otherwise, decrypt here...
+ retval = cast(PdfObject, retval)
+ retval = self._encryption.decrypt_object(
+ retval, indirect_reference.idnum, indirect_reference.generation
+ )
+ else:
+ if hasattr(self.stream, "getbuffer"):
+ buf = bytes(self.stream.getbuffer())
+ else:
+ p = self.stream.tell()
+ self.stream.seek(0, 0)
+ buf = self.stream.read(-1)
+ self.stream.seek(p, 0)
+ m = re.search(
+ rf"\s{indirect_reference.idnum}\s+{indirect_reference.generation}\s+obj".encode(),
+ buf,
+ )
+ if m is not None:
+ logger_warning(
+ f"Object {indirect_reference.idnum} {indirect_reference.generation} found",
+ __name__,
+ )
+ if indirect_reference.generation not in self.xref:
+ self.xref[indirect_reference.generation] = {}
+ self.xref[indirect_reference.generation][indirect_reference.idnum] = (
+ m.start(0) + 1
+ )
+ self.stream.seek(m.end(0) + 1)
+ skip_over_whitespace(self.stream)
+ self.stream.seek(-1, 1)
+ retval = read_object(self.stream, self) # type: ignore
+
+ # override encryption is used for the /Encrypt dictionary
+ if not self._override_encryption and self._encryption is not None:
+ # if we don't have the encryption key:
+ if not self._encryption.is_decrypted():
+ raise FileNotDecryptedError("File has not been decrypted")
+ # otherwise, decrypt here...
+ retval = cast(PdfObject, retval)
+ retval = self._encryption.decrypt_object(
+ retval, indirect_reference.idnum, indirect_reference.generation
+ )
+ else:
+ logger_warning(
+ f"Object {indirect_reference.idnum} {indirect_reference.generation} not defined.",
+ __name__,
+ )
+ if self.strict:
+ raise PdfReadError("Could not find object.")
+ self.cache_indirect_object(
+ indirect_reference.generation, indirect_reference.idnum, retval
+ )
+ return retval
+
+ def read_object_header(self, stream: StreamType) -> tuple[int, int]:
+ # Should never be necessary to read out whitespace, since the
+ # cross-reference table should put us in the right spot to read the
+ # object header. In reality some files have stupid cross-reference
+ # tables that are off by whitespace bytes.
+ skip_over_comment(stream)
+ extra = skip_over_whitespace(stream)
+ stream.seek(-1, 1)
+ idnum = read_until_whitespace(stream)
+ extra |= skip_over_whitespace(stream)
+ stream.seek(-1, 1)
+ generation = read_until_whitespace(stream)
+ extra |= skip_over_whitespace(stream)
+ stream.seek(-1, 1)
+
+ # although it's not used, it might still be necessary to read
+ _obj = stream.read(3)
+
+ read_non_whitespace(stream)
+ stream.seek(-1, 1)
+ if extra and self.strict:
+ logger_warning(
+ f"Superfluous whitespace found in object header {idnum} {generation}", # type: ignore
+ __name__,
+ )
+ return int(idnum), int(generation)
+
+ def cache_get_indirect_object(
+ self, generation: int, idnum: int
+ ) -> Optional[PdfObject]:
+ try:
+ return self.resolved_objects.get((generation, idnum))
+ except RecursionError:
+ raise PdfReadError("Maximum recursion depth reached.")
+
+ def cache_indirect_object(
+ self, generation: int, idnum: int, obj: Optional[PdfObject]
+ ) -> Optional[PdfObject]:
+ if (generation, idnum) in self.resolved_objects:
+ msg = f"Overwriting cache for {generation} {idnum}"
+ if self.strict:
+ raise PdfReadError(msg)
+ logger_warning(msg, __name__)
+ self.resolved_objects[(generation, idnum)] = obj
+ if obj is not None:
+ obj.indirect_reference = IndirectObject(idnum, generation, self)
+ return obj
+
+ def _replace_object(self, indirect: IndirectObject, obj: PdfObject) -> PdfObject:
+ # function reserved for future development
+ if indirect.pdf != self:
+ raise ValueError("Cannot update PdfReader with external object")
+ if (indirect.generation, indirect.idnum) not in self.resolved_objects:
+ raise ValueError("Cannot find referenced object")
+ self.resolved_objects[(indirect.generation, indirect.idnum)] = obj
+ obj.indirect_reference = indirect
+ return obj
+
+ def read(self, stream: StreamType) -> None:
+ """
+ Read and process the PDF stream, extracting necessary data.
+
+ Args:
+ stream: The PDF file stream.
+
+ """
+ self._basic_validation(stream)
+ self._find_eof_marker(stream)
+ startxref = self._find_startxref_pos(stream)
+ self._startxref = startxref
+
+ # check and eventually correct the startxref only if not strict
+ xref_issue_nr = self._get_xref_issues(stream, startxref)
+ if xref_issue_nr != 0:
+ if self.strict and xref_issue_nr:
+ raise PdfReadError("Broken xref table")
+ logger_warning(f"incorrect startxref pointer({xref_issue_nr})", __name__)
+
+ # read all cross-reference tables and their trailers
+ self._read_xref_tables_and_trailers(stream, startxref, xref_issue_nr)
+
+ # if not zero-indexed, verify that the table is correct; change it if necessary
+ if self.xref_index and not self.strict:
+ loc = stream.tell()
+ for gen, xref_entry in self.xref.items():
+ if gen == 65535:
+ continue
+ xref_k = sorted(
+ xref_entry.keys()
+ ) # ensure ascending to prevent damage
+ for id in xref_k:
+ stream.seek(xref_entry[id], 0)
+ try:
+ pid, _pgen = self.read_object_header(stream)
+ except ValueError:
+ self._rebuild_xref_table(stream)
+ break
+ if pid == id - self.xref_index:
+ # fixing index item per item is required for revised PDF.
+ self.xref[gen][pid] = self.xref[gen][id]
+ del self.xref[gen][id]
+ # if not, then either it's just plain wrong, or the
+ # non-zero-index is actually correct
+ stream.seek(loc, 0) # return to where it was
+
+ # remove wrong objects (not pointing to correct structures) - cf #2326
+ if not self.strict:
+ loc = stream.tell()
+ for gen, xref_entry in self.xref.items():
+ if gen == 65535:
+ continue
+ ids = list(xref_entry.keys())
+ for id in ids:
+ stream.seek(xref_entry[id], 0)
+ try:
+ self.read_object_header(stream)
+ except ValueError:
+ logger_warning(
+ f"Ignoring wrong pointing object {id} {gen} (offset {xref_entry[id]})",
+ __name__,
+ )
+ del xref_entry[id] # we can delete the id, we are parsing ids
+ stream.seek(loc, 0) # return to where it was
+
+ def _basic_validation(self, stream: StreamType) -> None:
+ """Ensure the stream is valid and not empty."""
+ stream.seek(0, os.SEEK_SET)
+ try:
+ header_byte = stream.read(5)
+ except UnicodeDecodeError:
+ raise UnsupportedOperation("cannot read header")
+ if header_byte == b"":
+ raise EmptyFileError("Cannot read an empty file")
+ if header_byte != b"%PDF-":
+ if self.strict:
+ raise PdfReadError(
+ f"PDF starts with '{header_byte.decode('utf8')}', "
+ "but '%PDF-' expected"
+ )
+ logger_warning(f"invalid pdf header: {header_byte}", __name__)
+ stream.seek(0, os.SEEK_END)
+
+ def _find_eof_marker(self, stream: StreamType) -> None:
+ """
+ Jump to the %%EOF marker.
+
+ According to the specs, the %%EOF marker should be at the very end of
+ the file. Hence for standard-compliant PDF documents this function will
+ read only the last part (DEFAULT_BUFFER_SIZE).
+ """
+ HEADER_SIZE = 8 # to parse whole file, Header is e.g. '%PDF-1.6'
+ line = b""
+ first = True
+ while not line.startswith(b"%%EOF"):
+ if line != b"" and first:
+ if any(
+ line.strip().endswith(tr) for tr in (b"%%EO", b"%%E", b"%%", b"%")
+ ):
+ # Consider the file as truncated while
+ # having enough confidence to carry on.
+ logger_warning("EOF marker seems truncated", __name__)
+ break
+ first = False
+ if b"startxref" in line:
+ logger_warning(
+ "CAUTION: startxref found while searching for %%EOF. "
+ "The file might be truncated and some data might not be read.",
+ __name__,
+ )
+ if stream.tell() < HEADER_SIZE:
+ if self.strict:
+ raise PdfReadError("EOF marker not found")
+ logger_warning("EOF marker not found", __name__)
+ line = read_previous_line(stream)
+
+ def _find_startxref_pos(self, stream: StreamType) -> int:
+ """
+ Find startxref entry - the location of the xref table.
+
+ Args:
+ stream:
+
+ Returns:
+ The bytes offset
+
+ """
+ line = read_previous_line(stream)
+ try:
+ startxref = int(line)
+ except ValueError:
+ # 'startxref' may be on the same line as the location
+ if not line.startswith(b"startxref"):
+ raise PdfReadError("startxref not found")
+ startxref = int(line[9:].strip())
+ logger_warning("startxref on same line as offset", __name__)
+ else:
+ line = read_previous_line(stream)
+ if not line.startswith(b"startxref"):
+ raise PdfReadError("startxref not found")
+ return startxref
+
+ def _read_standard_xref_table(self, stream: StreamType) -> None:
+ # standard cross-reference table
+ ref = stream.read(3)
+ if ref != b"ref":
+ raise PdfReadError("xref table read error")
+ read_non_whitespace(stream)
+ stream.seek(-1, 1)
+ first_time = True # check if the first time looking at the xref table
+ while True:
+ num = cast(int, read_object(stream, self))
+ if first_time and num != 0:
+ self.xref_index = num
+ if self.strict:
+ logger_warning(
+ "Xref table not zero-indexed. ID numbers for objects will be corrected.",
+ __name__,
+ )
+ # if table not zero indexed, could be due to error from when PDF was created
+ # which will lead to mismatched indices later on, only warned and corrected if self.strict==True
+ first_time = False
+ read_non_whitespace(stream)
+ stream.seek(-1, 1)
+ size = cast(int, read_object(stream, self))
+ if not isinstance(size, int):
+ logger_warning(
+ "Invalid/Truncated xref table. Rebuilding it.",
+ __name__,
+ )
+ self._rebuild_xref_table(stream)
+ stream.read()
+ return
+ read_non_whitespace(stream)
+ stream.seek(-1, 1)
+ cnt = 0
+ while cnt < size:
+ line = stream.read(20)
+ if not line:
+ raise PdfReadError("Unexpected empty line in Xref table.")
+
+ # It's very clear in section 3.4.3 of the PDF spec
+ # that all cross-reference table lines are a fixed
+ # 20 bytes (as of PDF 1.7). However, some files have
+ # 21-byte entries (or more) due to the use of \r\n
+ # (CRLF) EOL's. Detect that case, and adjust the line
+ # until it does not begin with a \r (CR) or \n (LF).
+ while line[0] in b"\x0D\x0A":
+ stream.seek(-20 + 1, 1)
+ line = stream.read(20)
+
+ # On the other hand, some malformed PDF files
+ # use a single character EOL without a preceding
+ # space. Detect that case, and seek the stream
+ # back one character (0-9 means we've bled into
+ # the next xref entry, t means we've bled into the
+ # text "trailer"):
+ if line[-1] in b"0123456789t":
+ stream.seek(-1, 1)
+
+ try:
+ offset_b, generation_b = line[:16].split(b" ")
+ entry_type_b = line[17:18]
+
+ offset, generation = int(offset_b), int(generation_b)
+ except Exception:
+ if hasattr(stream, "getbuffer"):
+ buf = bytes(stream.getbuffer())
+ else:
+ p = stream.tell()
+ stream.seek(0, 0)
+ buf = stream.read(-1)
+ stream.seek(p)
+
+ f = re.search(rf"{num}\s+(\d+)\s+obj".encode(), buf)
+ if f is None:
+ logger_warning(
+ f"entry {num} in Xref table invalid; object not found",
+ __name__,
+ )
+ generation = 65535
+ offset = -1
+ entry_type_b = b"f"
+ else:
+ logger_warning(
+ f"entry {num} in Xref table invalid but object found",
+ __name__,
+ )
+ generation = int(f.group(1))
+ offset = f.start()
+
+ if generation not in self.xref:
+ self.xref[generation] = {}
+ self.xref_free_entry[generation] = {}
+ if num in self.xref[generation]:
+ # It really seems like we should allow the last
+ # xref table in the file to override previous
+ # ones. Since we read the file backwards, assume
+ # any existing key is already set correctly.
+ pass
+ else:
+ if entry_type_b == b"n":
+ self.xref[generation][num] = offset
+ try:
+ self.xref_free_entry[generation][num] = entry_type_b == b"f"
+ except Exception:
+ pass
+ try:
+ self.xref_free_entry[65535][num] = entry_type_b == b"f"
+ except Exception:
+ pass
+ cnt += 1
+ num += 1
+ read_non_whitespace(stream)
+ stream.seek(-1, 1)
+ trailer_tag = stream.read(7)
+ if trailer_tag != b"trailer":
+ # more xrefs!
+ stream.seek(-7, 1)
+ else:
+ break
+
+ def _read_xref_tables_and_trailers(
+ self, stream: StreamType, startxref: Optional[int], xref_issue_nr: int
+ ) -> None:
+ """Read the cross-reference tables and trailers in the PDF stream."""
+ self.xref = {}
+ self.xref_free_entry = {}
+ self.xref_objStm = {}
+ self.trailer = DictionaryObject()
+ while startxref is not None:
+ # load the xref table
+ stream.seek(startxref, 0)
+ x = stream.read(1)
+ if x in b"\r\n":
+ x = stream.read(1)
+ if x == b"x":
+ startxref = self._read_xref(stream)
+ elif xref_issue_nr:
+ try:
+ self._rebuild_xref_table(stream)
+ break
+ except Exception:
+ xref_issue_nr = 0
+ elif x.isdigit():
+ try:
+ xrefstream = self._read_pdf15_xref_stream(stream)
+ except Exception as e:
+ if TK.ROOT in self.trailer:
+ logger_warning(
+ f"Previous trailer cannot be read: {e.args}", __name__
+ )
+ break
+ raise PdfReadError(f"Trailer cannot be read: {e!s}")
+ self._process_xref_stream(xrefstream)
+ if "/Prev" in xrefstream:
+ startxref = cast(int, xrefstream["/Prev"])
+ else:
+ break
+ else:
+ startxref = self._read_xref_other_error(stream, startxref)
+
+ def _process_xref_stream(self, xrefstream: DictionaryObject) -> None:
+ """Process and handle the xref stream."""
+ trailer_keys = TK.ROOT, TK.ENCRYPT, TK.INFO, TK.ID, TK.SIZE
+ for key in trailer_keys:
+ if key in xrefstream and key not in self.trailer:
+ self.trailer[NameObject(key)] = xrefstream.raw_get(key)
+ if "/XRefStm" in xrefstream:
+ p = self.stream.tell()
+ self.stream.seek(cast(int, xrefstream["/XRefStm"]) + 1, 0)
+ self._read_pdf15_xref_stream(self.stream)
+ self.stream.seek(p, 0)
+
+ def _read_xref(self, stream: StreamType) -> Optional[int]:
+ self._read_standard_xref_table(stream)
+ if stream.read(1) == b"":
+ return None
+ stream.seek(-1, 1)
+ read_non_whitespace(stream)
+ stream.seek(-1, 1)
+ new_trailer = cast(dict[str, Any], read_object(stream, self))
+ for key, value in new_trailer.items():
+ if key not in self.trailer:
+ self.trailer[key] = value
+ if "/XRefStm" in new_trailer:
+ p = stream.tell()
+ stream.seek(cast(int, new_trailer["/XRefStm"]) + 1, 0)
+ try:
+ self._read_pdf15_xref_stream(stream)
+ except Exception:
+ logger_warning(
+ f"XRef object at {new_trailer['/XRefStm']} can not be read, some object may be missing",
+ __name__,
+ )
+ stream.seek(p, 0)
+ if "/Prev" in new_trailer:
+ return new_trailer["/Prev"]
+ return None
+
+ def _read_xref_other_error(
+ self, stream: StreamType, startxref: int
+ ) -> Optional[int]:
+ # some PDFs have /Prev=0 in the trailer, instead of no /Prev
+ if startxref == 0:
+ if self.strict:
+ raise PdfReadError(
+ "/Prev=0 in the trailer (try opening with strict=False)"
+ )
+ logger_warning(
+ "/Prev=0 in the trailer - assuming there is no previous xref table",
+ __name__,
+ )
+ return None
+ # bad xref character at startxref. Let's see if we can find
+ # the xref table nearby, as we've observed this error with an
+ # off-by-one before.
+ stream.seek(-11, 1)
+ tmp = stream.read(20)
+ xref_loc = tmp.find(b"xref")
+ if xref_loc != -1:
+ startxref -= 10 - xref_loc
+ return startxref
+ # No explicit xref table, try finding a cross-reference stream.
+ stream.seek(startxref, 0)
+ for look in range(25): # value extended to cope with more linearized files
+ if stream.read(1).isdigit():
+ # This is not a standard PDF, consider adding a warning
+ startxref += look
+ return startxref
+ # no xref table found at specified location
+ if "/Root" in self.trailer and not self.strict:
+ # if Root has been already found, just raise warning
+ logger_warning("Invalid parent xref., rebuild xref", __name__)
+ try:
+ self._rebuild_xref_table(stream)
+ return None
+ except Exception:
+ raise PdfReadError("Cannot rebuild xref")
+ raise PdfReadError("Could not find xref table at specified location")
+
+ def _read_pdf15_xref_stream(
+ self, stream: StreamType
+ ) -> Union[ContentStream, EncodedStreamObject, DecodedStreamObject]:
+ """Read the cross-reference stream for PDF 1.5+."""
+ stream.seek(-1, 1)
+ idnum, generation = self.read_object_header(stream)
+ xrefstream = cast(ContentStream, read_object(stream, self))
+ if cast(str, xrefstream["/Type"]) != "/XRef":
+ raise PdfReadError(f"Unexpected type {xrefstream['/Type']!r}")
+ self.cache_indirect_object(generation, idnum, xrefstream)
+
+ # Index pairs specify the subsections in the dictionary.
+ # If none, create one subsection that spans everything.
+ if "/Size" not in xrefstream:
+ # According to table 17 of the PDF 2.0 specification, this key is required.
+ raise PdfReadError(f"Size missing from XRef stream {xrefstream!r}!")
+ idx_pairs = xrefstream.get("/Index", [0, xrefstream["/Size"]])
+
+ entry_sizes = cast(dict[Any, Any], xrefstream.get("/W"))
+ assert len(entry_sizes) >= 3
+ if self.strict and len(entry_sizes) > 3:
+ raise PdfReadError(f"Too many entry sizes: {entry_sizes}")
+
+ stream_data = BytesIO(xrefstream.get_data())
+
+ def get_entry(i: int) -> Union[int, tuple[int, ...]]:
+ # Reads the correct number of bytes for each entry. See the
+ # discussion of the W parameter in PDF spec table 17.
+ if entry_sizes[i] > 0:
+ d = stream_data.read(entry_sizes[i])
+ return convert_to_int(d, entry_sizes[i])
+
+ # PDF Spec Table 17: A value of zero for an element in the
+ # W array indicates...the default value shall be used
+ if i == 0:
+ return 1 # First value defaults to 1
+ return 0
+
+ def used_before(num: int, generation: Union[int, tuple[int, ...]]) -> bool:
+ # We move backwards through the xrefs, don't replace any.
+ return num in self.xref.get(generation, []) or num in self.xref_objStm # type: ignore
+
+ # Iterate through each subsection
+ self._read_xref_subsections(idx_pairs, get_entry, used_before)
+ return xrefstream
+
+ @staticmethod
+ def _get_xref_issues(stream: StreamType, startxref: int) -> int:
+ """
+ Return an int which indicates an issue. 0 means there is no issue.
+
+ Args:
+ stream:
+ startxref:
+
+ Returns:
+ 0 means no issue, other values represent specific issues.
+
+ """
+ if startxref == 0:
+ return 4
+
+ stream.seek(startxref - 1, 0) # -1 to check character before
+ line = stream.read(1)
+ if line == b"j":
+ line = stream.read(1)
+ if line not in b"\r\n \t":
+ return 1
+ line = stream.read(4)
+ if line != b"xref":
+ # not a xref so check if it is an XREF object
+ line = b""
+ while line in b"0123456789 \t":
+ line = stream.read(1)
+ if line == b"":
+ return 2
+ line += stream.read(2) # 1 char already read, +2 to check "obj"
+ if line.lower() != b"obj":
+ return 3
+ return 0
+
+ @classmethod
+ def _find_pdf_objects(cls, data: bytes) -> Iterable[tuple[int, int, int]]:
+ index = 0
+ ord_0 = ord("0")
+ ord_9 = ord("9")
+ while True:
+ index = data.find(b" obj", index)
+ if index == -1:
+ return
+
+ index_before_space = index - 1
+
+ # Skip whitespace backwards
+ while index_before_space >= 0 and data[index_before_space] in WHITESPACES_AS_BYTES:
+ index_before_space -= 1
+
+ # Read generation number
+ generation_end = index_before_space + 1
+ while index_before_space >= 0 and ord_0 <= data[index_before_space] <= ord_9:
+ index_before_space -= 1
+ generation_start = index_before_space + 1
+
+ # Skip whitespace
+ while index_before_space >= 0 and data[index_before_space] in WHITESPACES_AS_BYTES:
+ index_before_space -= 1
+
+ # Read object number
+ object_end = index_before_space + 1
+ while index_before_space >= 0 and ord_0 <= data[index_before_space] <= ord_9:
+ index_before_space -= 1
+ object_start = index_before_space + 1
+
+ # Validate
+ if object_start < object_end and generation_start < generation_end:
+ object_number = int(data[object_start:object_end])
+ generation_number = int(data[generation_start:generation_end])
+
+ yield object_number, generation_number, object_start
+
+ index += 4 # len(b" obj")
+
+ @classmethod
+ def _find_pdf_trailers(cls, data: bytes) -> Iterable[int]:
+ index = 0
+ data_length = len(data)
+ while True:
+ index = data.find(b"trailer", index)
+ if index == -1:
+ return
+
+ index_after_trailer = index + 7 # len(b"trailer")
+
+ # Skip whitespace
+ while index_after_trailer < data_length and data[index_after_trailer] in WHITESPACES_AS_BYTES:
+ index_after_trailer += 1
+
+ # Must be dictionary start
+ if index_after_trailer + 1 < data_length and data[index_after_trailer:index_after_trailer+2] == b"<<":
+ yield index_after_trailer # offset of '<<'
+
+ index += 7 # len(b"trailer")
+
+ def _rebuild_xref_table(self, stream: StreamType) -> None:
+ self.xref = {}
+ stream.seek(0, 0)
+ stream_data = stream.read(-1)
+
+ for object_number, generation_number, object_start in self._find_pdf_objects(stream_data):
+ if generation_number not in self.xref:
+ self.xref[generation_number] = {}
+ self.xref[generation_number][object_number] = object_start
+
+ logger_warning("parsing for Object Streams", __name__)
+ for generation_number in self.xref:
+ for object_number in self.xref[generation_number]:
+ # get_object in manual
+ stream.seek(self.xref[generation_number][object_number], 0)
+ try:
+ _ = self.read_object_header(stream)
+ obj = cast(StreamObject, read_object(stream, self))
+ if obj.get("/Type", "") != "/ObjStm":
+ continue
+ object_stream = BytesIO(obj.get_data())
+ actual_count = 0
+ while True:
+ current = read_until_whitespace(object_stream)
+ if not current.isdigit():
+ break
+ inner_object_number = int(current)
+ skip_over_whitespace(object_stream)
+ object_stream.seek(-1, 1)
+ current = read_until_whitespace(object_stream)
+ if not current.isdigit(): # pragma: no cover
+ break # pragma: no cover
+ inner_generation_number = int(current)
+ self.xref_objStm[inner_object_number] = (object_number, inner_generation_number)
+ actual_count += 1
+ if actual_count != obj.get("/N"): # pragma: no cover
+ logger_warning( # pragma: no cover
+ f"found {actual_count} objects within Object({object_number},{generation_number})"
+ f" whereas {obj.get('/N')} expected",
+ __name__,
+ )
+ except Exception: # could be multiple causes
+ pass
+
+ stream.seek(0, 0)
+ for position in self._find_pdf_trailers(stream_data):
+ stream.seek(position, 0)
+ new_trailer = cast(dict[Any, Any], read_object(stream, self))
+ # Here, we are parsing the file from start to end, the new data have to erase the existing.
+ for key, value in new_trailer.items():
+ self.trailer[key] = value
+
+ def _read_xref_subsections(
+ self,
+ idx_pairs: list[int],
+ get_entry: Callable[[int], Union[int, tuple[int, ...]]],
+ used_before: Callable[[int, Union[int, tuple[int, ...]]], bool],
+ ) -> None:
+ """Read and process the subsections of the xref."""
+ for start, size in self._pairs(idx_pairs):
+ # The subsections must increase
+ for num in range(start, start + size):
+ # The first entry is the type
+ xref_type = get_entry(0)
+ # The rest of the elements depend on the xref_type
+ if xref_type == 0:
+ # linked list of free objects
+ next_free_object = get_entry(1) # noqa: F841
+ next_generation = get_entry(2) # noqa: F841
+ elif xref_type == 1:
+ # objects that are in use but are not compressed
+ byte_offset = get_entry(1)
+ generation = get_entry(2)
+ if generation not in self.xref:
+ self.xref[generation] = {} # type: ignore
+ if not used_before(num, generation):
+ self.xref[generation][num] = byte_offset # type: ignore
+ elif xref_type == 2:
+ # compressed objects
+ objstr_num = get_entry(1)
+ obstr_idx = get_entry(2)
+ generation = 0 # PDF spec table 18, generation is 0
+ if not used_before(num, generation):
+ self.xref_objStm[num] = (objstr_num, obstr_idx)
+ elif self.strict:
+ raise PdfReadError(f"Unknown xref type: {xref_type}")
+
+ def _pairs(self, array: list[int]) -> Iterable[tuple[int, int]]:
+ """Iterate over pairs in the array."""
+ i = 0
+ while i + 1 < len(array):
+ yield array[i], array[i + 1]
+ i += 2
+
+ def decrypt(self, password: Union[str, bytes]) -> PasswordType:
+ """
+ When using an encrypted / secured PDF file with the PDF Standard
+ encryption handler, this function will allow the file to be decrypted.
+ It checks the given password against the document's user password and
+ owner password, and then stores the resulting decryption key if either
+ password is correct.
+
+ It does not matter which password was matched. Both passwords provide
+ the correct decryption key that will allow the document to be used with
+ this library.
+
+ Args:
+ password: The password to match.
+
+ Returns:
+ An indicator if the document was decrypted and whether it was the
+ owner password or the user password.
+
+ """
+ if not self._encryption:
+ raise PdfReadError("Not encrypted file")
+ # TODO: raise Exception for wrong password
+ return self._encryption.verify(password)
+
+ @property
+ def is_encrypted(self) -> bool:
+ """
+ Read-only boolean property showing whether this PDF file is encrypted.
+
+ Note that this property, if true, will remain true even after the
+ :meth:`decrypt()` method is called.
+ """
+ return TK.ENCRYPT in self.trailer
+
+ def add_form_topname(self, name: str) -> Optional[DictionaryObject]:
+ """
+ Add a top level form that groups all form fields below it.
+
+ Args:
+ name: text string of the "/T" Attribute of the created object
+
+ Returns:
+ The created object. ``None`` means no object was created.
+
+ """
+ catalog = self.root_object
+
+ if "/AcroForm" not in catalog or not isinstance(
+ catalog["/AcroForm"], DictionaryObject
+ ):
+ return None
+ acroform = cast(DictionaryObject, catalog[NameObject("/AcroForm")])
+ if "/Fields" not in acroform:
+ # TODO: No error but this may be extended for XFA Forms
+ return None
+
+ interim = DictionaryObject()
+ interim[NameObject("/T")] = TextStringObject(name)
+ interim[NameObject("/Kids")] = acroform[NameObject("/Fields")]
+ self.cache_indirect_object(
+ 0,
+ max(i for (g, i) in self.resolved_objects if g == 0) + 1,
+ interim,
+ )
+ arr = ArrayObject()
+ arr.append(interim.indirect_reference)
+ acroform[NameObject("/Fields")] = arr
+ for o in cast(ArrayObject, interim["/Kids"]):
+ obj = o.get_object()
+ if "/Parent" in obj:
+ logger_warning(
+ f"Top Level Form Field {obj.indirect_reference} have a non-expected parent",
+ __name__,
+ )
+ obj[NameObject("/Parent")] = interim.indirect_reference
+ return interim
+
+ def rename_form_topname(self, name: str) -> Optional[DictionaryObject]:
+ """
+ Rename top level form field that all form fields below it.
+
+ Args:
+ name: text string of the "/T" field of the created object
+
+ Returns:
+ The modified object. ``None`` means no object was modified.
+
+ """
+ catalog = self.root_object
+
+ if "/AcroForm" not in catalog or not isinstance(
+ catalog["/AcroForm"], DictionaryObject
+ ):
+ return None
+ acroform = cast(DictionaryObject, catalog[NameObject("/AcroForm")])
+ if "/Fields" not in acroform:
+ return None
+
+ interim = cast(
+ DictionaryObject,
+ cast(ArrayObject, acroform[NameObject("/Fields")])[0].get_object(),
+ )
+ interim[NameObject("/T")] = TextStringObject(name)
+ return interim
+
+ def _repr_mimebundle_(
+ self,
+ include: Union[None, Iterable[str]] = None,
+ exclude: Union[None, Iterable[str]] = None,
+ ) -> dict[str, Any]:
+ """
+ Integration into Jupyter Notebooks.
+
+ This method returns a dictionary that maps a mime-type to its
+ representation.
+
+ .. seealso::
+
+ https://ipython.readthedocs.io/en/stable/config/integrating.html
+ """
+ self.stream.seek(0)
+ pdf_data = self.stream.read()
+ data = {
+ "application/pdf": pdf_data,
+ }
+
+ if include is not None:
+ # Filter representations based on include list
+ data = {k: v for k, v in data.items() if k in include}
+
+ if exclude is not None:
+ # Remove representations based on exclude list
+ data = {k: v for k, v in data.items() if k not in exclude}
+
+ return data
diff --git a/venv/lib/python3.12/site-packages/pypdf/_text_extraction/__init__.py b/venv/lib/python3.12/site-packages/pypdf/_text_extraction/__init__.py
new file mode 100644
index 0000000..fd51c24
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_text_extraction/__init__.py
@@ -0,0 +1,245 @@
+"""
+Code related to text extraction.
+
+Some parts are still in _page.py. In doubt, they will stay there.
+"""
+
+import math
+from typing import Any, Callable, Optional, Union
+
+from .._font import Font
+from ..generic import DictionaryObject, TextStringObject, encode_pdfdocencoding
+
+CUSTOM_RTL_MIN: int = -1
+CUSTOM_RTL_MAX: int = -1
+CUSTOM_RTL_SPECIAL_CHARS: list[int] = []
+LAYOUT_NEW_BT_GROUP_SPACE_WIDTHS: int = 5
+
+
+class OrientationNotFoundError(Exception):
+ pass
+
+
+def set_custom_rtl(
+ _min: Union[str, int, None] = None,
+ _max: Union[str, int, None] = None,
+ specials: Union[str, list[int], None] = None,
+) -> tuple[int, int, list[int]]:
+ """
+ Change the Right-To-Left and special characters custom parameters.
+
+ Args:
+ _min: The new minimum value for the range of custom characters that
+ will be written right to left.
+ If set to ``None``, the value will not be changed.
+ If set to an integer or string, it will be converted to its ASCII code.
+ The default value is -1, which sets no additional range to be converted.
+ _max: The new maximum value for the range of custom characters that will
+ be written right to left.
+ If set to ``None``, the value will not be changed.
+ If set to an integer or string, it will be converted to its ASCII code.
+ The default value is -1, which sets no additional range to be converted.
+ specials: The new list of special characters to be inserted in the
+ current insertion order.
+ If set to ``None``, the current value will not be changed.
+ If set to a string, it will be converted to a list of ASCII codes.
+ The default value is an empty list.
+
+ Returns:
+ A tuple containing the new values for ``CUSTOM_RTL_MIN``,
+ ``CUSTOM_RTL_MAX``, and ``CUSTOM_RTL_SPECIAL_CHARS``.
+
+ """
+ global CUSTOM_RTL_MIN, CUSTOM_RTL_MAX, CUSTOM_RTL_SPECIAL_CHARS
+ if isinstance(_min, int):
+ CUSTOM_RTL_MIN = _min
+ elif isinstance(_min, str):
+ CUSTOM_RTL_MIN = ord(_min)
+ if isinstance(_max, int):
+ CUSTOM_RTL_MAX = _max
+ elif isinstance(_max, str):
+ CUSTOM_RTL_MAX = ord(_max)
+ if isinstance(specials, str):
+ CUSTOM_RTL_SPECIAL_CHARS = [ord(x) for x in specials]
+ elif isinstance(specials, list):
+ CUSTOM_RTL_SPECIAL_CHARS = specials
+ return CUSTOM_RTL_MIN, CUSTOM_RTL_MAX, CUSTOM_RTL_SPECIAL_CHARS
+
+
+def mult(m: list[float], n: list[float]) -> list[float]:
+ return [
+ m[0] * n[0] + m[1] * n[2],
+ m[0] * n[1] + m[1] * n[3],
+ m[2] * n[0] + m[3] * n[2],
+ m[2] * n[1] + m[3] * n[3],
+ m[4] * n[0] + m[5] * n[2] + n[4],
+ m[4] * n[1] + m[5] * n[3] + n[5],
+ ]
+
+
+def orient(m: list[float]) -> int:
+ if m[3] > 1e-6:
+ return 0
+ if m[3] < -1e-6:
+ return 180
+ if m[1] > 0:
+ return 90
+ return 270
+
+
+def crlf_space_check(
+ text: str,
+ cmtm_prev: tuple[list[float], list[float]],
+ cmtm_matrix: tuple[list[float], list[float]],
+ memo_cmtm: tuple[list[float], list[float]],
+ font_resource: Optional[DictionaryObject],
+ orientations: tuple[int, ...],
+ output: str,
+ font_size: float,
+ visitor_text: Optional[Callable[[Any, Any, Any, Any, Any], None]],
+ str_widths: float,
+ spacewidth: float,
+ str_height: float,
+) -> tuple[str, str, list[float], list[float]]:
+ cm_prev = cmtm_prev[0]
+ tm_prev = cmtm_prev[1]
+ cm_matrix = cmtm_matrix[0]
+ tm_matrix = cmtm_matrix[1]
+ memo_cm = memo_cmtm[0]
+ memo_tm = memo_cmtm[1]
+
+ m_prev = mult(tm_prev, cm_prev)
+ m = mult(tm_matrix, cm_matrix)
+ orientation = orient(m)
+ delta_x = m[4] - m_prev[4]
+ delta_y = m[5] - m_prev[5]
+ # Table 108 of the 1.7 reference ("Text positioning operators")
+ scale_prev_x = math.sqrt(tm_prev[0]**2 + tm_prev[1]**2)
+ scale_prev_y = math.sqrt(tm_prev[2]**2 + tm_prev[3]**2)
+ scale_y = math.sqrt(tm_matrix[2]**2 + tm_matrix[3]**2)
+ cm_prev = m
+
+ if orientation not in orientations:
+ raise OrientationNotFoundError
+ if orientation in (0, 180):
+ moved_height: float = delta_y
+ moved_width: float = delta_x
+ elif orientation in (90, 270):
+ moved_height = delta_x
+ moved_width = delta_y
+ try:
+ if abs(moved_height) > 0.8 * min(str_height * scale_prev_y, font_size * scale_y):
+ if (output + text)[-1] != "\n":
+ output += text + "\n"
+ if visitor_text is not None:
+ visitor_text(
+ text + "\n",
+ memo_cm,
+ memo_tm,
+ font_resource,
+ font_size,
+ )
+ text = ""
+ elif (
+ (moved_width >= (spacewidth + str_widths) * scale_prev_x)
+ and (output + text)[-1] != " "
+ ):
+ text += " "
+ except Exception:
+ pass
+ tm_prev = tm_matrix.copy()
+ cm_prev = cm_matrix.copy()
+ return text, output, cm_prev, tm_prev
+
+
+def get_text_operands(
+ operands: list[Union[str, TextStringObject]],
+ cm_matrix: list[float],
+ tm_matrix: list[float],
+ font: Font,
+ orientations: tuple[int, ...]
+) -> tuple[str, bool]:
+ t: str = ""
+ is_str_operands = False
+ m = mult(tm_matrix, cm_matrix)
+ orientation = orient(m)
+ if orientation in orientations and len(operands) > 0:
+ if isinstance(operands[0], str):
+ t = operands[0]
+ is_str_operands = True
+ else:
+ t = ""
+ tt: bytes = (
+ encode_pdfdocencoding(operands[0])
+ if isinstance(operands[0], str)
+ else operands[0]
+ )
+ if isinstance(font.encoding, str):
+ try:
+ t = tt.decode(font.encoding, "surrogatepass") # apply str encoding
+ except Exception:
+ # the data does not match the expectation,
+ # we use the alternative ;
+ # text extraction may not be good
+ t = tt.decode(
+ "utf-16-be" if font.encoding == "charmap" else "charmap",
+ "surrogatepass",
+ ) # apply str encoding
+ else: # apply dict encoding
+ t = "".join(
+ [font.encoding[x] if x in font.encoding else bytes((x,)).decode() for x in tt]
+ )
+ return (t, is_str_operands)
+
+
+def get_display_str(
+ text: str,
+ cm_matrix: list[float],
+ tm_matrix: list[float],
+ font_resource: Optional[DictionaryObject],
+ font: Font,
+ text_operands: str,
+ font_size: float,
+ rtl_dir: bool,
+ visitor_text: Optional[Callable[[Any, Any, Any, Any, Any], None]]
+) -> tuple[str, bool, float]:
+ # "\u0590 - \u08FF \uFB50 - \uFDFF"
+ widths: float = 0.0
+ for x in [font.character_map.get(x, x) for x in text_operands]:
+ # x can be a sequence of bytes ; ex: habibi.pdf
+ if len(x) == 1:
+ xx = ord(x)
+ else:
+ xx = 1
+ # fmt: off
+ if (
+ # cases where the current inserting order is kept
+ (xx <= 0x2F) # punctuations but...
+ or 0x3A <= xx <= 0x40 # numbers (x30-39)
+ or 0x2000 <= xx <= 0x206F # upper punctuations..
+ or 0x20A0 <= xx <= 0x21FF # but (numbers) indices/exponents
+ or xx in CUSTOM_RTL_SPECIAL_CHARS # customized....
+ ):
+ text = x + text if rtl_dir else text + x
+ elif ( # right-to-left characters set
+ 0x0590 <= xx <= 0x08FF
+ or 0xFB1D <= xx <= 0xFDFF
+ or 0xFE70 <= xx <= 0xFEFF
+ or CUSTOM_RTL_MIN <= xx <= CUSTOM_RTL_MAX
+ ):
+ if not rtl_dir:
+ rtl_dir = True
+ if visitor_text is not None:
+ visitor_text(text, cm_matrix, tm_matrix, font_resource, font_size)
+ text = ""
+ text = x + text
+ else: # left-to-right
+ if rtl_dir:
+ rtl_dir = False
+ if visitor_text is not None:
+ visitor_text(text, cm_matrix, tm_matrix, font_resource, font_size)
+ text = ""
+ text = text + x
+ widths += font.space_width if x == " " else font.text_width(x)
+ # fmt: on
+ return text, rtl_dir, widths
diff --git a/venv/lib/python3.12/site-packages/pypdf/_text_extraction/_layout_mode/__init__.py b/venv/lib/python3.12/site-packages/pypdf/_text_extraction/_layout_mode/__init__.py
new file mode 100644
index 0000000..d315160
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_text_extraction/_layout_mode/__init__.py
@@ -0,0 +1,16 @@
+"""Layout mode text extraction extension for pypdf"""
+from ..._font import Font
+from ._fixed_width_page import (
+ fixed_char_width,
+ fixed_width_page,
+ text_show_operations,
+ y_coordinate_groups,
+)
+
+__all__ = [
+ "Font",
+ "fixed_char_width",
+ "fixed_width_page",
+ "text_show_operations",
+ "y_coordinate_groups",
+]
diff --git a/venv/lib/python3.12/site-packages/pypdf/_text_extraction/_layout_mode/_fixed_width_page.py b/venv/lib/python3.12/site-packages/pypdf/_text_extraction/_layout_mode/_fixed_width_page.py
new file mode 100644
index 0000000..48f654e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_text_extraction/_layout_mode/_fixed_width_page.py
@@ -0,0 +1,400 @@
+"""Extract PDF text preserving the layout of the source PDF"""
+
+from collections.abc import Iterator
+from itertools import groupby
+from math import ceil
+from pathlib import Path
+from typing import Any, Literal, Optional, TypedDict
+
+from ..._font import Font
+from ..._utils import logger_warning
+from .. import LAYOUT_NEW_BT_GROUP_SPACE_WIDTHS
+from ._text_state_manager import TextStateManager
+from ._text_state_params import TextStateParams
+
+
+class BTGroup(TypedDict):
+ """
+ Dict describing a line of text rendered within a BT/ET operator pair.
+ If multiple text show operations render text on the same line, the text
+ will be combined into a single BTGroup dict.
+
+ Keys:
+ tx: x coordinate of first character in BTGroup
+ ty: y coordinate of first character in BTGroup
+ font_size: nominal font size
+ font_height: effective font height
+ text: rendered text
+ displaced_tx: x coordinate of last character in BTGroup
+ flip_sort: -1 if page is upside down, else 1
+ """
+
+ tx: float
+ ty: float
+ font_size: float
+ font_height: float
+ text: str
+ displaced_tx: float
+ flip_sort: Literal[-1, 1]
+
+
+def bt_group(tj_op: TextStateParams, rendered_text: str, dispaced_tx: float) -> BTGroup:
+ """
+ BTGroup constructed from a TextStateParams instance, rendered text, and
+ displaced tx value.
+
+ Args:
+ tj_op (TextStateParams): TextStateParams instance
+ rendered_text (str): rendered text
+ dispaced_tx (float): x coordinate of last character in BTGroup
+
+ """
+ return BTGroup(
+ tx=tj_op.tx,
+ ty=tj_op.ty,
+ font_size=tj_op.font_size,
+ font_height=tj_op.font_height,
+ text=rendered_text,
+ displaced_tx=dispaced_tx,
+ flip_sort=-1 if tj_op.flip_vertical else 1,
+ )
+
+
+def recurs_to_target_op(
+ ops: Iterator[tuple[list[Any], bytes]],
+ text_state_mgr: TextStateManager,
+ end_target: Literal[b"Q", b"ET"],
+ fonts: dict[str, Font],
+ strip_rotated: bool = True,
+) -> tuple[list[BTGroup], list[TextStateParams]]:
+ """
+ Recurse operators between BT/ET and/or q/Q operators managing the transform
+ stack and capturing text positioning and rendering data.
+
+ Args:
+ ops: iterator of operators in content stream
+ text_state_mgr: a TextStateManager instance
+ end_target: Either b"Q" (ends b"q" op) or b"ET" (ends b"BT" op)
+ fonts: font dictionary as returned by PageObject._layout_mode_fonts()
+
+ Returns:
+ tuple: list of BTGroup dicts + list of TextStateParams dataclass instances.
+
+ """
+ # 1 entry per line of text rendered within each BT/ET operation.
+ bt_groups: list[BTGroup] = []
+
+ # 1 entry per text show operator (Tj/TJ/'/")
+ tj_ops: list[TextStateParams] = []
+
+ if end_target == b"Q":
+ # add new q level. cm's added at this level will be popped at next b'Q'
+ text_state_mgr.add_q()
+
+ for operands, op in ops:
+ # The loop is broken by the end target, or exits normally when there are no more ops.
+ if op == end_target:
+ if op == b"Q":
+ text_state_mgr.remove_q()
+ if op == b"ET":
+ if not tj_ops:
+ return bt_groups, tj_ops
+ _text = ""
+ bt_idx = 0 # idx of first tj in this bt group
+ last_displaced_tx = tj_ops[bt_idx].displaced_tx
+ last_ty = tj_ops[bt_idx].ty
+ for _idx, _tj in enumerate(
+ tj_ops
+ ): # ... build text from new Tj operators
+ if strip_rotated and _tj.rotated:
+ continue
+ if not _tj.font.interpretable: # generates warning
+ continue
+ # if the y position of the text is greater than the font height, assume
+ # the text is on a new line and start a new group
+ if abs(_tj.ty - last_ty) > _tj.font_height:
+ if _text.strip():
+ bt_groups.append(
+ bt_group(tj_ops[bt_idx], _text, last_displaced_tx)
+ )
+ bt_idx = _idx
+ _text = ""
+
+ # if the x position of the text is less than the last x position by
+ # more than 5 spaces widths, assume the text order should be flipped
+ # and start a new group
+ if (
+ last_displaced_tx - _tj.tx
+ > _tj.space_tx * LAYOUT_NEW_BT_GROUP_SPACE_WIDTHS
+ ):
+ if _text.strip():
+ bt_groups.append(
+ bt_group(tj_ops[bt_idx], _text, last_displaced_tx)
+ )
+ bt_idx = _idx
+ last_displaced_tx = _tj.displaced_tx
+ _text = ""
+
+ # calculate excess x translation based on ending tx of previous Tj.
+ # multiply by bool (_idx != bt_idx) to ensure spaces aren't double
+ # applied to the first tj of a BTGroup in fixed_width_page().
+ excess_tx = round(_tj.tx - last_displaced_tx, 3) * (_idx != bt_idx)
+ # space_tx could be 0 if either Tz or font_size was 0 for this _tj.
+ spaces = int(excess_tx // _tj.space_tx) if _tj.space_tx else 0
+ new_text = f'{" " * spaces}{_tj.txt}'
+
+ last_ty = _tj.ty
+ _text = f"{_text}{new_text}"
+ last_displaced_tx = _tj.displaced_tx
+ if _text:
+ bt_groups.append(bt_group(tj_ops[bt_idx], _text, last_displaced_tx))
+ text_state_mgr.reset_tm()
+ break
+ if op == b"q":
+ bts, tjs = recurs_to_target_op(
+ ops, text_state_mgr, b"Q", fonts, strip_rotated
+ )
+ bt_groups.extend(bts)
+ tj_ops.extend(tjs)
+ elif op == b"cm":
+ text_state_mgr.add_cm(*operands)
+ elif op == b"BT":
+ bts, tjs = recurs_to_target_op(
+ ops, text_state_mgr, b"ET", fonts, strip_rotated
+ )
+ bt_groups.extend(bts)
+ tj_ops.extend(tjs)
+ elif op == b"Tj":
+ tj_ops.append(text_state_mgr.text_state_params(operands[0]))
+ elif op == b"TJ":
+ _tj = text_state_mgr.text_state_params()
+ for tj_op in operands[0]:
+ if isinstance(tj_op, bytes):
+ _tj = text_state_mgr.text_state_params(tj_op)
+ tj_ops.append(_tj)
+ else:
+ text_state_mgr.add_trm(_tj.displacement_matrix(td_offset=tj_op))
+ elif op == b"'":
+ text_state_mgr.reset_trm()
+ text_state_mgr.add_tm([0, -text_state_mgr.TL])
+ tj_ops.append(text_state_mgr.text_state_params(operands[0]))
+ elif op == b'"':
+ text_state_mgr.reset_trm()
+ text_state_mgr.set_state_param(b"Tw", operands[0])
+ text_state_mgr.set_state_param(b"Tc", operands[1])
+ text_state_mgr.add_tm([0, -text_state_mgr.TL])
+ tj_ops.append(text_state_mgr.text_state_params(operands[2]))
+ elif op in (b"Td", b"Tm", b"TD", b"T*"):
+ text_state_mgr.reset_trm()
+ if op == b"Tm":
+ text_state_mgr.reset_tm()
+ elif op == b"TD":
+ text_state_mgr.set_state_param(b"TL", -operands[1])
+ elif op == b"T*":
+ operands = [0, -text_state_mgr.TL]
+ text_state_mgr.add_tm(operands)
+ elif op == b"Tf":
+ text_state_mgr.set_font(fonts[operands[0]], operands[1])
+ else: # handle Tc, Tw, Tz, TL, and Ts operators
+ text_state_mgr.set_state_param(op, operands)
+ else:
+ logger_warning(
+ f"Unbalanced target operations, expected {end_target!r}.",
+ __name__,
+ )
+ return bt_groups, tj_ops
+
+
+def y_coordinate_groups(
+ bt_groups: list[BTGroup], debug_path: Optional[Path] = None
+) -> dict[int, list[BTGroup]]:
+ """
+ Group text operations by rendered y coordinate, i.e. the line number.
+
+ Args:
+ bt_groups: list of dicts as returned by text_show_operations()
+ debug_path (Path, optional): Path to a directory for saving debug output.
+
+ Returns:
+ Dict[int, List[BTGroup]]: dict of lists of text rendered by each BT operator
+ keyed by y coordinate
+
+ """
+ ty_groups = {
+ ty: sorted(grp, key=lambda x: x["tx"])
+ for ty, grp in groupby(
+ bt_groups, key=lambda bt_grp: int(bt_grp["ty"] * bt_grp["flip_sort"])
+ )
+ }
+ # combine groups whose y coordinates differ by less than the effective font height
+ # (accounts for mixed fonts and other minor oddities)
+ last_ty = next(iter(ty_groups))
+ last_txs = {int(_t["tx"]) for _t in ty_groups[last_ty] if _t["text"].strip()}
+ for ty in list(ty_groups)[1:]:
+ fsz = min(ty_groups[_y][0]["font_height"] for _y in (ty, last_ty))
+ txs = {int(_t["tx"]) for _t in ty_groups[ty] if _t["text"].strip()}
+ # prevent merge if both groups are rendering in the same x position.
+ no_text_overlap = not (txs & last_txs)
+ offset_less_than_font_height = abs(ty - last_ty) < fsz
+ if no_text_overlap and offset_less_than_font_height:
+ ty_groups[last_ty] = sorted(
+ ty_groups.pop(ty) + ty_groups[last_ty], key=lambda x: x["tx"]
+ )
+ last_txs |= txs
+ else:
+ last_ty = ty
+ last_txs = txs
+ if debug_path: # pragma: no cover
+ import json # noqa: PLC0415
+
+ debug_path.joinpath("bt_groups.json").write_text(
+ json.dumps(ty_groups, indent=2, default=str), "utf-8"
+ )
+ return ty_groups
+
+
+def text_show_operations(
+ ops: Iterator[tuple[list[Any], bytes]],
+ fonts: dict[str, Font],
+ strip_rotated: bool = True,
+ debug_path: Optional[Path] = None,
+) -> list[BTGroup]:
+ """
+ Extract text from BT/ET operator pairs.
+
+ Args:
+ ops (Iterator[Tuple[List, bytes]]): iterator of operators in content stream
+ fonts (Dict[str, Font]): font dictionary
+ strip_rotated: Removes text if rotated w.r.t. to the page. Defaults to True.
+ debug_path (Path, optional): Path to a directory for saving debug output.
+
+ Returns:
+ List[BTGroup]: list of dicts of text rendered by each BT operator
+
+ """
+ state_mgr = TextStateManager() # transformation stack manager
+ bt_groups: list[BTGroup] = [] # BT operator dict
+ tj_ops: list[TextStateParams] = [] # Tj/TJ operator data
+ for operands, op in ops:
+ if op in (b"BT", b"q"):
+ bts, tjs = recurs_to_target_op(
+ ops, state_mgr, b"ET" if op == b"BT" else b"Q", fonts, strip_rotated
+ )
+ bt_groups.extend(bts)
+ tj_ops.extend(tjs)
+ elif op == b"Tf":
+ state_mgr.set_font(fonts[operands[0]], operands[1])
+ else: # set Tc, Tw, Tz, TL, and Ts if required. ignores all other ops
+ state_mgr.set_state_param(op, operands)
+
+ if any(tj.rotated for tj in tj_ops):
+ if strip_rotated:
+ logger_warning(
+ "Rotated text discovered. Output will be incomplete.", __name__
+ )
+ else:
+ logger_warning(
+ "Rotated text discovered. Layout will be degraded.", __name__
+ )
+ if not all(tj.font.interpretable for tj in tj_ops):
+ logger_warning(
+ "PDF contains an uninterpretable font. Output will be incomplete.", __name__
+ )
+
+ # left align the data, i.e. decrement all tx values by min(tx)
+ min_x = min((x["tx"] for x in bt_groups), default=0.0)
+ bt_groups = [
+ dict(ogrp, tx=ogrp["tx"] - min_x, displaced_tx=ogrp["displaced_tx"] - min_x) # type: ignore[misc]
+ for ogrp in sorted(
+ bt_groups, key=lambda x: (x["ty"] * x["flip_sort"], -x["tx"]), reverse=True
+ )
+ ]
+
+ if debug_path: # pragma: no cover
+ import json # noqa: PLC0415
+
+ debug_path.joinpath("bts.json").write_text(
+ json.dumps(bt_groups, indent=2, default=str), "utf-8"
+ )
+ debug_path.joinpath("tjs.json").write_text(
+ json.dumps(
+ tj_ops, indent=2, default=lambda x: getattr(x, "to_dict", str)(x)
+ ),
+ "utf-8",
+ )
+ return bt_groups
+
+
+def fixed_char_width(bt_groups: list[BTGroup], scale_weight: float = 1.25) -> float:
+ """
+ Calculate average character width weighted by the length of the rendered
+ text in each sample for conversion to fixed-width layout.
+
+ Args:
+ bt_groups (List[BTGroup]): List of dicts of text rendered by each
+ BT operator
+
+ Returns:
+ float: fixed character width
+
+ """
+ char_widths = []
+ for _bt in bt_groups:
+ _len = len(_bt["text"]) * scale_weight
+ char_widths.append(((_bt["displaced_tx"] - _bt["tx"]) / _len, _len))
+ return sum(_w * _l for _w, _l in char_widths) / sum(_l for _, _l in char_widths)
+
+
+def fixed_width_page(
+ ty_groups: dict[int, list[BTGroup]], char_width: float, space_vertically: bool, font_height_weight: float
+) -> str:
+ """
+ Generate page text from text operations grouped by rendered y coordinate.
+
+ Args:
+ ty_groups: dict of text show ops as returned by y_coordinate_groups()
+ char_width: fixed character width
+ space_vertically: include blank lines inferred from y distance + font height.
+ font_height_weight: multiplier for font height when calculating blank lines.
+
+ Returns:
+ str: page text in a fixed width format that closely adheres to the rendered
+ layout in the source pdf.
+
+ """
+ lines: list[str] = []
+ last_y_coord = 0
+ table = str.maketrans(dict.fromkeys(range(14, 32), " "))
+ for y_coord, line_data in ty_groups.items():
+ if space_vertically and lines:
+ fh = line_data[0]["font_height"]
+ blank_lines = 0 if fh == 0 else (
+ int(abs(y_coord - last_y_coord) / (fh * font_height_weight)) - 1
+ )
+ lines.extend([""] * blank_lines)
+
+ line_parts = [] # It uses a list to construct the line, avoiding string concatenation.
+ current_len = 0 # Track the size with int instead of len(str) overhead.
+ last_disp = 0.0
+ for bt_op in line_data:
+ tx = bt_op["tx"]
+ offset = int(tx // char_width)
+ needed_spaces = offset - current_len
+ if needed_spaces > 0 and ceil(last_disp) < int(tx):
+ padding = " " * needed_spaces
+ line_parts.append(padding)
+ current_len += needed_spaces
+
+ raw_text = bt_op["text"]
+ text = raw_text.translate(table)
+ line_parts.append(text)
+ current_len += len(text)
+ last_disp = bt_op["displaced_tx"]
+
+ full_line = "".join(line_parts).rstrip()
+ if full_line.strip() or (space_vertically and lines):
+ lines.append(full_line)
+
+ last_y_coord = y_coord
+
+ return "\n".join(lines)
diff --git a/venv/lib/python3.12/site-packages/pypdf/_text_extraction/_layout_mode/_text_state_manager.py b/venv/lib/python3.12/site-packages/pypdf/_text_extraction/_layout_mode/_text_state_manager.py
new file mode 100644
index 0000000..947cdd4
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_text_extraction/_layout_mode/_text_state_manager.py
@@ -0,0 +1,221 @@
+"""manage the PDF transform stack during "layout" mode text extraction"""
+
+from collections import ChainMap, Counter
+from collections import ChainMap as ChainMapType
+from collections import Counter as CounterType
+from collections.abc import MutableMapping
+from typing import Any, Union
+
+from ..._font import Font
+from ...errors import PdfReadError
+from .. import mult
+from ._text_state_params import TextStateParams
+
+TextStateManagerChainMapType = ChainMapType[Union[int, str], Union[float, bool]]
+TextStateManagerDictType = MutableMapping[Union[int, str], Union[float, bool]]
+
+
+class TextStateManager:
+ """
+ Tracks the current text state including cm/tm/trm transformation matrices.
+
+ Attributes:
+ transform_stack (ChainMap): ChainMap of cm/tm transformation matrices
+ q_queue (Counter[int]): Counter of q operators
+ q_depth (List[int]): list of q operator nesting levels
+ Tc (float): character spacing
+ Tw (float): word spacing
+ Tz (int): horizontal scaling
+ TL (float): leading
+ Ts (float): text rise
+ font (Font): font object
+ font_size (int | float): font size
+
+ """
+
+ def __init__(self) -> None:
+ self.transform_stack: TextStateManagerChainMapType = ChainMap(
+ self.new_transform()
+ )
+ self.q_queue: CounterType[int] = Counter()
+ self.q_depth = [0]
+ self.Tc: float = 0.0
+ self.Tw: float = 0.0
+ self.Tz: float = 100.0
+ self.TL: float = 0.0
+ self.Ts: float = 0.0
+ self.font_stack: list[tuple[Union[Font, None], Union[int, float]]] = []
+ self.font: Union[Font, None] = None
+ self.font_size: Union[int, float] = 0
+
+ def set_state_param(self, op: bytes, value: Union[float, list[Any]]) -> None:
+ """
+ Set a text state parameter. Supports Tc, Tz, Tw, TL, and Ts operators.
+
+ Args:
+ op: operator read from PDF stream as bytes. No action is taken
+ for unsupported operators (see supported operators above).
+ value (float | List[Any]): new parameter value. If a list,
+ value[0] is used.
+
+ """
+ if op not in [b"Tc", b"Tz", b"Tw", b"TL", b"Ts"]:
+ return
+ self.__setattr__(op.decode(), value[0] if isinstance(value, list) else value)
+
+ def set_font(self, font: Font, size: float) -> None:
+ """
+ Set the current font and font_size.
+
+ Args:
+ font (Font): a layout mode Font
+ size (float): font size
+
+ """
+ self.font = font
+ self.font_size = size
+
+ def text_state_params(self, value: Union[bytes, str] = "") -> TextStateParams:
+ """
+ Create a TextStateParams instance to display a text string. Type[bytes] values
+ will be decoded implicitly.
+
+ Args:
+ value (str | bytes): text to associate with the captured state.
+
+ Raises:
+ PdfReadError: if font not set (no Tf operator in incoming pdf content stream)
+
+ Returns:
+ TextStateParams: current text state parameters
+
+ """
+ if not isinstance(self.font, Font):
+ raise PdfReadError(
+ "font not set: is PDF missing a Tf operator?"
+ ) # pragma: no cover
+ if isinstance(value, bytes):
+ try:
+ if isinstance(self.font.encoding, str):
+ txt = value.decode(self.font.encoding, "surrogatepass")
+ else:
+ txt = "".join(
+ self.font.encoding[x]
+ if x in self.font.encoding
+ else bytes((x,)).decode()
+ for x in value
+ )
+ except (UnicodeEncodeError, UnicodeDecodeError):
+ txt = value.decode("utf-8", "replace")
+ txt = "".join(
+ self.font.character_map.get(x, x) for x in txt
+ )
+ else:
+ txt = value
+ return TextStateParams(
+ txt,
+ self.font,
+ self.font_size,
+ self.Tc,
+ self.Tw,
+ self.Tz,
+ self.TL,
+ self.Ts,
+ self.effective_transform,
+ )
+
+ @staticmethod
+ def raw_transform(
+ _a: float = 1.0,
+ _b: float = 0.0,
+ _c: float = 0.0,
+ _d: float = 1.0,
+ _e: float = 0.0,
+ _f: float = 0.0,
+ ) -> dict[int, float]:
+ """Only a/b/c/d/e/f matrix params"""
+ return dict(zip(range(6), map(float, (_a, _b, _c, _d, _e, _f))))
+
+ @staticmethod
+ def new_transform(
+ _a: float = 1.0,
+ _b: float = 0.0,
+ _c: float = 0.0,
+ _d: float = 1.0,
+ _e: float = 0.0,
+ _f: float = 0.0,
+ is_text: bool = False,
+ is_render: bool = False,
+ ) -> TextStateManagerDictType:
+ """Standard a/b/c/d/e/f matrix params + 'is_text' and 'is_render' keys"""
+ result: Any = TextStateManager.raw_transform(_a, _b, _c, _d, _e, _f)
+ result.update({"is_text": is_text, "is_render": is_render})
+ return result
+
+ def reset_tm(self) -> TextStateManagerChainMapType:
+ """Clear all transforms from chainmap having is_text==True or is_render==True"""
+ while (
+ self.transform_stack.maps[0]["is_text"]
+ or self.transform_stack.maps[0]["is_render"]
+ ):
+ self.transform_stack = self.transform_stack.parents
+ return self.transform_stack
+
+ def reset_trm(self) -> TextStateManagerChainMapType:
+ """Clear all transforms from chainmap having is_render==True"""
+ while self.transform_stack.maps[0]["is_render"]:
+ self.transform_stack = self.transform_stack.parents
+ return self.transform_stack
+
+ def remove_q(self) -> TextStateManagerChainMapType:
+ """Rewind to stack prior state after closing a 'q' with internal 'cm' ops"""
+ self.font, self.font_size = self.font_stack.pop(-1)
+ self.transform_stack = self.reset_tm()
+ self.transform_stack.maps = self.transform_stack.maps[
+ self.q_queue.pop(self.q_depth.pop(), 0) :
+ ]
+ return self.transform_stack
+
+ def add_q(self) -> None:
+ """Add another level to q_queue"""
+ self.font_stack.append((self.font, self.font_size))
+ self.q_depth.append(len(self.q_depth))
+
+ def add_cm(self, *args: Any) -> TextStateManagerChainMapType:
+ """Concatenate an additional transform matrix"""
+ self.transform_stack = self.reset_tm()
+ self.q_queue.update(self.q_depth[-1:])
+ self.transform_stack = self.transform_stack.new_child(self.new_transform(*args))
+ return self.transform_stack
+
+ def _complete_matrix(self, operands: list[float]) -> list[float]:
+ """Adds a, b, c, and d to an "e/f only" operand set (e.g Td)"""
+ if len(operands) == 2: # this is a Td operator or equivalent
+ operands = [1.0, 0.0, 0.0, 1.0, *operands]
+ return operands
+
+ def add_tm(self, operands: list[float]) -> TextStateManagerChainMapType:
+ """Append a text transform matrix"""
+ self.transform_stack = self.transform_stack.new_child(
+ self.new_transform( # type: ignore[misc]
+ *self._complete_matrix(operands), is_text=True # type: ignore[arg-type]
+ )
+ )
+ return self.transform_stack
+
+ def add_trm(self, operands: list[float]) -> TextStateManagerChainMapType:
+ """Append a text rendering transform matrix"""
+ self.transform_stack = self.transform_stack.new_child(
+ self.new_transform( # type: ignore[misc]
+ *self._complete_matrix(operands), is_text=True, is_render=True # type: ignore[arg-type]
+ )
+ )
+ return self.transform_stack
+
+ @property
+ def effective_transform(self) -> list[float]:
+ """Current effective transform accounting for cm, tm, and trm transforms"""
+ eff_transform = [*self.transform_stack.maps[0].values()]
+ for transform in self.transform_stack.maps[1:]:
+ eff_transform = mult(eff_transform, transform) # type: ignore[arg-type] # dict has int keys 0-5
+ return eff_transform
diff --git a/venv/lib/python3.12/site-packages/pypdf/_text_extraction/_layout_mode/_text_state_params.py b/venv/lib/python3.12/site-packages/pypdf/_text_extraction/_layout_mode/_text_state_params.py
new file mode 100644
index 0000000..5203f12
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_text_extraction/_layout_mode/_text_state_params.py
@@ -0,0 +1,135 @@
+"""A dataclass that captures the CTM and Text State for a tj operation"""
+
+import math
+from dataclasses import dataclass, field
+from typing import Any, Union
+
+from ..._font import Font
+from .. import mult, orient
+
+
+@dataclass
+class TextStateParams:
+ """
+ Text state parameters and operator values for a single text value in a
+ TJ or Tj PDF operation.
+
+ Attributes:
+ txt (str): the text to be rendered.
+ font (Font): font object
+ font_size (int | float): font size
+ Tc (float): character spacing. Defaults to 0.0.
+ Tw (float): word spacing. Defaults to 0.0.
+ Tz (float): horizontal scaling. Defaults to 100.0.
+ TL (float): leading, vertical displacement between text lines. Defaults to 0.0.
+ Ts (float): text rise. Used for super/subscripts. Defaults to 0.0.
+ transform (List[float]): effective transformation matrix.
+ tx (float): x cood of rendered text, i.e. self.transform[4]
+ ty (float): y cood of rendered text. May differ from self.transform[5] per self.Ts.
+ displaced_tx (float): x coord immediately following rendered text
+ space_tx (float): tx for a space character
+ font_height (float): effective font height accounting for CTM
+ flip_vertical (bool): True if y axis has been inverted (i.e. if self.transform[3] < 0.)
+ rotated (bool): True if the text orientation is rotated with respect to the page.
+
+ """
+
+ txt: str
+ font: Font
+ font_size: Union[int, float]
+ Tc: float = 0.0
+ Tw: float = 0.0
+ Tz: float = 100.0
+ TL: float = 0.0
+ Ts: float = 0.0
+ transform: list[float] = field(
+ default_factory=lambda: [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
+ )
+ tx: float = field(default=0.0, init=False)
+ ty: float = field(default=0.0, init=False)
+ displaced_tx: float = field(default=0.0, init=False)
+ space_tx: float = field(default=0.0, init=False)
+ font_height: float = field(default=0.0, init=False)
+ flip_vertical: bool = field(default=False, init=False)
+ rotated: bool = field(default=False, init=False)
+
+ def __post_init__(self) -> None:
+ if orient(self.transform) in (90, 270):
+ self.transform = mult(
+ [1.0, -self.transform[1], -self.transform[2], 1.0, 0.0, 0.0],
+ self.transform,
+ )
+ self.rotated = True
+ # self.transform[0] AND self.transform[3] < 0 indicates true rotation.
+ # If only self.transform[3] < 0, the y coords are simply inverted.
+ if orient(self.transform) == 180 and self.transform[0] < -1e-6:
+ self.transform = mult([-1.0, 0.0, 0.0, -1.0, 0.0, 0.0], self.transform)
+ self.rotated = True
+ self.displaced_tx = self.displaced_transform()[4]
+ self.tx = self.transform[4]
+ self.ty = self.render_transform()[5]
+ self.space_tx = round(self.word_tx(" "), 3)
+ if self.space_tx < 1e-6:
+ # if the " " char is assigned 0 width (e.g. for fine tuned spacing
+ # with TJ int operators a la crazyones.pdf), calculate space_tx as
+ # a td_offset of -1 * font.space_width where font.space_width is
+ # the space_width calculated in _font.py.
+ self.space_tx = round(self.word_tx("", -self.font.space_width), 3)
+ self.font_height = self.font_size * math.sqrt(
+ self.transform[1] ** 2 + self.transform[3] ** 2
+ )
+ # flip_vertical handles PDFs generated by Microsoft Word's "publish" command.
+ self.flip_vertical = self.transform[3] < -1e-6 # inverts y axis
+
+ def font_size_matrix(self) -> list[float]:
+ """Font size matrix"""
+ return [
+ self.font_size * (self.Tz / 100.0),
+ 0.0,
+ 0.0,
+ self.font_size,
+ 0.0,
+ self.Ts,
+ ]
+
+ def displaced_transform(self) -> list[float]:
+ """Effective transform matrix after text has been rendered."""
+ return mult(self.displacement_matrix(), self.transform)
+
+ def render_transform(self) -> list[float]:
+ """Effective transform matrix accounting for font size, Tz, and Ts."""
+ return mult(self.font_size_matrix(), self.transform)
+
+ def displacement_matrix(
+ self, word: Union[str, None] = None, td_offset: float = 0.0
+ ) -> list[float]:
+ """
+ Text displacement matrix
+
+ Args:
+ word (str, optional): Defaults to None in which case self.txt displacement is
+ returned.
+ td_offset (float, optional): translation applied by TD operator. Defaults to 0.0.
+
+ """
+ word = word if word is not None else self.txt
+ return [1.0, 0.0, 0.0, 1.0, self.word_tx(word, td_offset), 0.0]
+
+ def word_tx(self, word: str, td_offset: float = 0.0) -> float:
+ """Horizontal text displacement for any word according this text state"""
+ width: float = 0.0
+ for char in word:
+ if char == " ":
+ width += self.font.space_width
+ else:
+ width += self.font.text_width(char)
+ return (
+ (self.font_size * ((width - td_offset) / 1000.0))
+ + self.Tc
+ + word.count(" ") * self.Tw
+ ) * (self.Tz / 100.0)
+
+ @staticmethod
+ def to_dict(inst: "TextStateParams") -> dict[str, Any]:
+ """Dataclass to dict for json.dumps serialization"""
+ return {k: getattr(inst, k) for k in inst.__dataclass_fields__ if k != "font"}
diff --git a/venv/lib/python3.12/site-packages/pypdf/_text_extraction/_text_extractor.py b/venv/lib/python3.12/site-packages/pypdf/_text_extraction/_text_extractor.py
new file mode 100644
index 0000000..9a61c5d
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_text_extraction/_text_extractor.py
@@ -0,0 +1,351 @@
+# Copyright (c) 2006, Mathieu Fenniak
+# Copyright (c) 2007, Ashish Kulkarni
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+
+import math
+from typing import Any, Callable, Optional, Union
+
+from .._font import Font, FontDescriptor
+from ..generic import DictionaryObject, TextStringObject
+from . import OrientationNotFoundError, crlf_space_check, get_display_str, get_text_operands, mult
+
+
+class TextExtraction:
+ """
+ A class to handle PDF text extraction operations.
+
+ This class encapsulates all the state and operations needed for extracting
+ text from PDF content streams, replacing the nested functions and nonlocal
+ variables in the original implementation.
+ """
+
+ def __init__(self) -> None:
+ self._font_width_maps: dict[str, tuple[dict[Any, float], str, float]] = {}
+
+ # Text extraction state variables
+ self.cm_matrix: list[float] = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
+ self.tm_matrix: list[float] = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
+ self.cm_stack: list[
+ tuple[
+ list[float],
+ Optional[DictionaryObject],
+ Font,
+ float,
+ float,
+ float,
+ float,
+ ]
+ ] = []
+
+ # Store the last modified matrices; can be an intermediate position
+ self.cm_prev: list[float] = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
+ self.tm_prev: list[float] = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
+
+ # Store the position at the beginning of building the text
+ self.memo_cm: list[float] = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
+ self.memo_tm: list[float] = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
+
+ self.char_scale = 1.0
+ self.space_scale = 1.0
+ self._space_width: float = 500.0 # will be set correctly at first Tf
+ self._actual_str_size: dict[str, float] = {
+ "str_widths": 0.0,
+ "str_height": 0.0,
+ } # will be set to string length calculation result
+ self.TL = 0.0
+ self.font_size = 12.0 # init just in case of
+
+ # Text extraction variables
+ self.text: str = ""
+ self.output: str = ""
+ self.rtl_dir: bool = False # right-to-left
+ self.font_resource: Optional[DictionaryObject] = None
+ self.font = Font(
+ name = "NotInitialized",
+ sub_type="Unknown",
+ encoding="charmap",
+ font_descriptor=FontDescriptor(),
+ )
+ self.orientations: tuple[int, ...] = (0, 90, 180, 270)
+ self.visitor_text: Optional[Callable[[Any, Any, Any, Any, Any], None]] = None
+ self.font_resources: dict[str, DictionaryObject] = {}
+ self.fonts: dict[str, Font] = {}
+
+ self.operation_handlers = {
+ b"BT": self._handle_bt,
+ b"ET": self._handle_et,
+ b"q": self._handle_save_graphics_state,
+ b"Q": self._handle_restore_graphics_state,
+ b"cm": self._handle_cm,
+ b"Tz": self._handle_tz,
+ b"Tw": self._handle_tw,
+ b"TL": self._handle_tl,
+ b"Tf": self._handle_tf,
+ b"Td": self._handle_td,
+ b"Tm": self._handle_tm,
+ b"T*": self._handle_t_star,
+ b"Tj": self._handle_tj_operation,
+ }
+
+ def initialize_extraction(
+ self,
+ orientations: tuple[int, ...] = (0, 90, 180, 270),
+ visitor_text: Optional[Callable[[Any, Any, Any, Any, Any], None]] = None,
+ font_resources: Optional[dict[str, DictionaryObject]] = None,
+ fonts: Optional[dict[str, Font]] = None
+ ) -> None:
+ """Initialize the extractor with extraction parameters."""
+ self.orientations = orientations
+ self.visitor_text = visitor_text
+ self.font_resources = font_resources or {}
+ self.fonts = fonts or {}
+
+ # Reset state
+ self.text = ""
+ self.output = ""
+ self.rtl_dir = False
+
+ def compute_str_widths(self, str_widths: float) -> float:
+ return str_widths / 1000
+
+ def process_operation(self, operator: bytes, operands: list[Any]) -> None:
+ if operator in self.operation_handlers:
+ handler = self.operation_handlers[operator]
+ str_widths = handler(operands)
+
+ # Post-process operations that affect text positioning
+ if operator in {b"Td", b"Tm", b"T*", b"Tj"}:
+ self._post_process_text_operation(str_widths or 0.0)
+
+ def _post_process_text_operation(self, str_widths: float) -> None:
+ """Handle common post-processing for text positioning operations."""
+ try:
+ self.text, self.output, self.cm_prev, self.tm_prev = crlf_space_check(
+ self.text,
+ (self.cm_prev, self.tm_prev),
+ (self.cm_matrix, self.tm_matrix),
+ (self.memo_cm, self.memo_tm),
+ self.font_resource,
+ self.orientations,
+ self.output,
+ self.font_size,
+ self.visitor_text,
+ str_widths,
+ self.compute_str_widths(self.font_size * self._space_width),
+ self._actual_str_size["str_height"],
+ )
+ if self.text == "":
+ self.memo_cm = self.cm_matrix.copy()
+ self.memo_tm = self.tm_matrix.copy()
+ except OrientationNotFoundError:
+ pass
+
+ def _handle_tj(
+ self,
+ text: str,
+ operands: list[Union[str, TextStringObject]],
+ cm_matrix: list[float],
+ tm_matrix: list[float],
+ font_resource: Optional[DictionaryObject],
+ font: Font,
+ orientations: tuple[int, ...],
+ font_size: float,
+ rtl_dir: bool,
+ visitor_text: Optional[Callable[[Any, Any, Any, Any, Any], None]],
+ actual_str_size: dict[str, float],
+ ) -> tuple[str, bool, dict[str, float]]:
+ text_operands, is_str_operands = get_text_operands(
+ operands, cm_matrix, tm_matrix, font, orientations
+ )
+ if is_str_operands:
+ text += text_operands
+ font_widths = sum([font.space_width if x == " " else font.text_width(x) for x in text_operands])
+ else:
+ text, rtl_dir, font_widths = get_display_str(
+ text,
+ cm_matrix,
+ tm_matrix, # text matrix
+ font_resource,
+ font,
+ text_operands,
+ font_size,
+ rtl_dir,
+ visitor_text,
+ )
+ actual_str_size["str_widths"] += font_widths * font_size
+ actual_str_size["str_height"] = font_size
+ return text, rtl_dir, actual_str_size
+
+ def _flush_text(self) -> None:
+ """Flush accumulated text to output and call visitor if present."""
+ self.output += self.text
+ if self.visitor_text is not None:
+ self.visitor_text(self.text, self.memo_cm, self.memo_tm, self.font_resource, self.font_size)
+ self.text = ""
+ self.memo_cm = self.cm_matrix.copy()
+ self.memo_tm = self.tm_matrix.copy()
+
+ # Operation handlers
+
+ def _handle_bt(self, operands: list[Any]) -> None:
+ """Handle BT (Begin Text) operation - Table 5.4 page 405."""
+ self.tm_matrix = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
+ self._flush_text()
+
+ def _handle_et(self, operands: list[Any]) -> None:
+ """Handle ET (End Text) operation - Table 5.4 page 405."""
+ self._flush_text()
+
+ def _handle_save_graphics_state(self, operands: list[Any]) -> None:
+ """Handle q (Save graphics state) operation - Table 4.7 page 219."""
+ self.cm_stack.append(
+ (
+ self.cm_matrix,
+ self.font_resource,
+ self.font,
+ self.font_size,
+ self.char_scale,
+ self.space_scale,
+ self.TL,
+ )
+ )
+
+ def _handle_restore_graphics_state(self, operands: list[Any]) -> None:
+ """Handle Q (Restore graphics state) operation - Table 4.7 page 219."""
+ try:
+ (
+ self.cm_matrix,
+ self.font_resource,
+ self.font,
+ self.font_size,
+ self.char_scale,
+ self.space_scale,
+ self.TL,
+ ) = self.cm_stack.pop()
+ except Exception:
+ self.cm_matrix = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
+
+ def _handle_cm(self, operands: list[Any]) -> None:
+ """Handle cm (Modify current matrix) operation - Table 4.7 page 219."""
+ self.output += self.text
+ if self.visitor_text is not None:
+ self.visitor_text(self.text, self.memo_cm, self.memo_tm, self.font_resource, self.font_size)
+ self.text = ""
+ try:
+ self.cm_matrix = mult([float(operand) for operand in operands[:6]], self.cm_matrix)
+ except Exception:
+ self.cm_matrix = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
+ self.memo_cm = self.cm_matrix.copy()
+ self.memo_tm = self.tm_matrix.copy()
+
+ def _handle_tz(self, operands: list[Any]) -> None:
+ """Handle Tz (Set horizontal text scaling) operation - Table 5.2 page 398."""
+ self.char_scale = float(operands[0]) / 100 if operands else 1.0
+
+ def _handle_tw(self, operands: list[Any]) -> None:
+ """Handle Tw (Set word spacing) operation - Table 5.2 page 398."""
+ self.space_scale = 1.0 + float(operands[0] if operands else 0.0)
+
+ def _handle_tl(self, operands: list[Any]) -> None:
+ """Handle TL (Set Text Leading) operation - Table 5.2 page 398."""
+ scale_x = math.sqrt(self.tm_matrix[0] ** 2 + self.tm_matrix[2] ** 2)
+ self.TL = float(operands[0] if operands else 0.0) * self.font_size * scale_x
+
+ def _handle_tf(self, operands: list[Any]) -> None:
+ """Handle Tf (Set font size) operation - Table 5.2 page 398."""
+ if self.text != "":
+ self.output += self.text # .translate(cmap)
+ if self.visitor_text is not None:
+ self.visitor_text(self.text, self.memo_cm, self.memo_tm, self.font_resource, self.font_size)
+ self.text = ""
+ self.memo_cm = self.cm_matrix.copy()
+ self.memo_tm = self.tm_matrix.copy()
+ try:
+ self.font_resource = self.font_resources[operands[0]]
+ self.font = self.fonts[operands[0]]
+ except KeyError: # font not found
+ self.font_resource = None
+ font_descriptor = FontDescriptor()
+ self.font = Font(
+ "Unknown",
+ space_width=250,
+ encoding=dict.fromkeys(range(256), "�"),
+ font_descriptor=font_descriptor,
+ character_map={},
+ character_widths=font_descriptor.character_widths
+ )
+
+ self._space_width = self.font.space_width / 2 # Actually the width of _half_ a space...
+ try:
+ self.font_size = float(operands[1])
+ except Exception:
+ pass # keep previous size
+
+ def _handle_td(self, operands: list[Any]) -> float:
+ """Handle Td (Move text position) operation - Table 5.5 page 406."""
+ # A special case is a translating only tm:
+ # tm = [1, 0, 0, 1, e, f]
+ # i.e. tm[4] += tx, tm[5] += ty.
+ tx, ty = float(operands[0]), float(operands[1])
+ self.tm_matrix[4] += tx * self.tm_matrix[0] + ty * self.tm_matrix[2]
+ self.tm_matrix[5] += tx * self.tm_matrix[1] + ty * self.tm_matrix[3]
+ str_widths = self.compute_str_widths(self._actual_str_size["str_widths"])
+ self._actual_str_size["str_widths"] = 0.0
+ return str_widths
+
+ def _handle_tm(self, operands: list[Any]) -> float:
+ """Handle Tm (Set text matrix) operation - Table 5.5 page 406."""
+ self.tm_matrix = [float(operand) for operand in operands[:6]]
+ str_widths = self.compute_str_widths(self._actual_str_size["str_widths"])
+ self._actual_str_size["str_widths"] = 0.0
+ return str_widths
+
+ def _handle_t_star(self, operands: list[Any]) -> float:
+ """Handle T* (Move to next line) operation - Table 5.5 page 406."""
+ self.tm_matrix[4] -= self.TL * self.tm_matrix[2]
+ self.tm_matrix[5] -= self.TL * self.tm_matrix[3]
+ str_widths = self.compute_str_widths(self._actual_str_size["str_widths"])
+ self._actual_str_size["str_widths"] = 0.0
+ return str_widths
+
+ def _handle_tj_operation(self, operands: list[Any]) -> float:
+ """Handle Tj (Show text) operation - Table 5.5 page 406."""
+ self.text, self.rtl_dir, self._actual_str_size = self._handle_tj(
+ self.text,
+ operands,
+ self.cm_matrix,
+ self.tm_matrix,
+ self.font_resource,
+ self.font,
+ self.orientations,
+ self.font_size,
+ self.rtl_dir,
+ self.visitor_text,
+ self._actual_str_size,
+ )
+ return 0.0 # str_widths will be handled in post-processing
diff --git a/venv/lib/python3.12/site-packages/pypdf/_utils.py b/venv/lib/python3.12/site-packages/pypdf/_utils.py
new file mode 100644
index 0000000..7c00c46
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_utils.py
@@ -0,0 +1,631 @@
+# Copyright (c) 2006, Mathieu Fenniak
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+
+"""Utility functions for PDF library."""
+__author__ = "Mathieu Fenniak"
+__author_email__ = "biziqe@mathieu.fenniak.net"
+
+import functools
+import logging
+import re
+import sys
+import warnings
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from io import DEFAULT_BUFFER_SIZE
+from os import SEEK_CUR
+from re import Pattern
+from typing import (
+ IO,
+ Any,
+ Optional,
+ Union,
+ overload,
+)
+
+if sys.version_info[:2] >= (3, 10):
+ # Python 3.10+: https://www.python.org/dev/peps/pep-0484/
+ from typing import TypeAlias
+else:
+ from typing_extensions import TypeAlias
+
+if sys.version_info >= (3, 11):
+ from typing import Self
+else:
+ from typing_extensions import Self
+
+from .errors import (
+ STREAM_TRUNCATED_PREMATURELY,
+ DeprecationError,
+ PdfStreamError,
+)
+
+TransformationMatrixType: TypeAlias = tuple[
+ tuple[float, float, float], tuple[float, float, float], tuple[float, float, float]
+]
+CompressedTransformationMatrix: TypeAlias = tuple[
+ float, float, float, float, float, float
+]
+
+StreamType = IO[Any]
+StrByteType = Union[str, StreamType]
+
+
+def parse_iso8824_date(text: Optional[str]) -> Optional[datetime]:
+ orgtext = text
+ if not text:
+ return None
+ if text[0].isdigit():
+ text = "D:" + text
+ if text.endswith(("Z", "z")):
+ text += "0000"
+ text = text.replace("z", "+").replace("Z", "+").replace("'", "")
+ i = max(text.find("+"), text.find("-"))
+ if i > 0 and i != len(text) - 5:
+ text += "00"
+ for f in (
+ "D:%Y",
+ "D:%Y%m",
+ "D:%Y%m%d",
+ "D:%Y%m%d%H",
+ "D:%Y%m%d%H%M",
+ "D:%Y%m%d%H%M%S",
+ "D:%Y%m%d%H%M%S%z",
+ ):
+ try:
+ d = datetime.strptime(text, f) # noqa: DTZ007
+ except ValueError:
+ continue
+ else:
+ if text.endswith("+0000"):
+ d = d.replace(tzinfo=timezone.utc)
+ return d
+ raise ValueError(f"Can not convert date: {orgtext}")
+
+
+def format_iso8824_date(dt: datetime) -> str:
+ """
+ Convert a datetime object to PDF date string format.
+
+ Converts datetime to the PDF date format D:YYYYMMDDHHmmSSOHH'mm
+ as specified in the PDF Reference.
+
+ Args:
+ dt: A datetime object to convert.
+
+ Returns:
+ A date string in PDF format.
+ """
+ date_str = dt.strftime("D:%Y%m%d%H%M%S")
+ if dt.tzinfo is not None:
+ offset = dt.utcoffset()
+ assert offset is not None
+ total_seconds = int(offset.total_seconds())
+ hours, remainder = divmod(abs(total_seconds), 3600)
+ minutes = remainder // 60
+ sign = "+" if total_seconds >= 0 else "-"
+ date_str += f"{sign}{hours:02d}'{minutes:02d}'"
+ return date_str
+
+
+def _get_max_pdf_version_header(header1: str, header2: str) -> str:
+ versions = (
+ "%PDF-1.3",
+ "%PDF-1.4",
+ "%PDF-1.5",
+ "%PDF-1.6",
+ "%PDF-1.7",
+ "%PDF-2.0",
+ )
+ pdf_header_indices = []
+ if header1 in versions:
+ pdf_header_indices.append(versions.index(header1))
+ if header2 in versions:
+ pdf_header_indices.append(versions.index(header2))
+ if len(pdf_header_indices) == 0:
+ raise ValueError(f"Neither {header1!r} nor {header2!r} are proper headers")
+ return versions[max(pdf_header_indices)]
+
+
+WHITESPACES = (b"\x00", b"\t", b"\n", b"\f", b"\r", b" ")
+WHITESPACES_AS_BYTES = b"".join(WHITESPACES)
+WHITESPACES_AS_REGEXP = b"[" + WHITESPACES_AS_BYTES + b"]"
+
+
+def read_until_whitespace(stream: StreamType, maxchars: Optional[int] = None) -> bytes:
+ """
+ Read non-whitespace characters and return them.
+
+ Stops upon encountering whitespace or when maxchars is reached.
+
+ Args:
+ stream: The data stream from which was read.
+ maxchars: The maximum number of bytes returned; by default unlimited.
+
+ Returns:
+ The data which was read.
+
+ """
+ txt = b""
+ while True:
+ tok = stream.read(1)
+ if tok.isspace() or not tok:
+ break
+ txt += tok
+ if len(txt) == maxchars:
+ break
+ return txt
+
+
+def read_non_whitespace(stream: StreamType) -> bytes:
+ """
+ Find and read the next non-whitespace character (ignores whitespace).
+
+ Args:
+ stream: The data stream from which was read.
+
+ Returns:
+ The data which was read.
+
+ """
+ tok = stream.read(1)
+ while tok in WHITESPACES:
+ tok = stream.read(1)
+ return tok
+
+
+def skip_over_whitespace(stream: StreamType) -> bool:
+ """
+ Similar to read_non_whitespace, but return a boolean if at least one
+ whitespace character was read.
+
+ Args:
+ stream: The data stream from which was read.
+
+ Returns:
+ True if one or more whitespace was skipped, otherwise return False.
+
+ """
+ tok = stream.read(1)
+ cnt = 0
+ while tok in WHITESPACES:
+ cnt += 1
+ tok = stream.read(1)
+ return cnt > 0
+
+
+def check_if_whitespace_only(value: bytes) -> bool:
+ """
+ Check if the given value consists of whitespace characters only.
+
+ Args:
+ value: The bytes to check.
+
+ Returns:
+ True if the value only has whitespace characters, otherwise return False.
+
+ """
+ return all(b in WHITESPACES_AS_BYTES for b in value)
+
+
+def skip_over_comment(stream: StreamType) -> None:
+ tok = stream.read(1)
+ stream.seek(-1, 1)
+ if tok == b"%":
+ while tok not in (b"\n", b"\r"):
+ tok = stream.read(1)
+ if tok == b"":
+ raise PdfStreamError("File ended unexpectedly.")
+
+
+def read_until_regex(stream: StreamType, regex: Pattern[bytes]) -> bytes:
+ """
+ Read until the regular expression pattern matched (ignore the match).
+ Treats EOF on the underlying stream as the end of the token to be matched.
+
+ Args:
+ regex: re.Pattern
+
+ Returns:
+ The read bytes.
+
+ """
+ name = b""
+ while True:
+ tok = stream.read(16)
+ if not tok:
+ return name
+ m = regex.search(name + tok)
+ if m is not None:
+ stream.seek(m.start() - (len(name) + len(tok)), 1)
+ name = (name + tok)[: m.start()]
+ break
+ name += tok
+ return name
+
+
+def read_block_backwards(stream: StreamType, to_read: int) -> bytes:
+ """
+ Given a stream at position X, read a block of size to_read ending at position X.
+
+ This changes the stream's position to the beginning of where the block was
+ read.
+
+ Args:
+ stream:
+ to_read:
+
+ Returns:
+ The data which was read.
+
+ """
+ if stream.tell() < to_read:
+ raise PdfStreamError("Could not read malformed PDF file")
+ # Seek to the start of the block we want to read.
+ stream.seek(-to_read, SEEK_CUR)
+ read = stream.read(to_read)
+ # Seek to the start of the block we read after reading it.
+ stream.seek(-to_read, SEEK_CUR)
+ return read
+
+
+def read_previous_line(stream: StreamType) -> bytes:
+ """
+ Given a byte stream with current position X, return the previous line.
+
+ All characters between the first CR/LF byte found before X
+ (or, the start of the file, if no such byte is found) and position X
+ After this call, the stream will be positioned one byte after the
+ first non-CRLF character found beyond the first CR/LF byte before X,
+ or, if no such byte is found, at the beginning of the stream.
+
+ Args:
+ stream: StreamType:
+
+ Returns:
+ The data which was read.
+
+ """
+ line_content = []
+ found_crlf = False
+ if stream.tell() == 0:
+ raise PdfStreamError(STREAM_TRUNCATED_PREMATURELY)
+ while True:
+ to_read = min(DEFAULT_BUFFER_SIZE, stream.tell())
+ if to_read == 0:
+ break
+ # Read the block. After this, our stream will be one
+ # beyond the initial position.
+ block = read_block_backwards(stream, to_read)
+ idx = len(block) - 1
+ if not found_crlf:
+ # We haven't found our first CR/LF yet.
+ # Read off characters until we hit one.
+ while idx >= 0 and block[idx] not in b"\r\n":
+ idx -= 1
+ if idx >= 0:
+ found_crlf = True
+ if found_crlf:
+ # We found our first CR/LF already (on this block or
+ # a previous one).
+ # Our combined line is the remainder of the block
+ # plus any previously read blocks.
+ line_content.append(block[idx + 1 :])
+ # Continue to read off any more CRLF characters.
+ while idx >= 0 and block[idx] in b"\r\n":
+ idx -= 1
+ else:
+ # Didn't find CR/LF yet - add this block to our
+ # previously read blocks and continue.
+ line_content.append(block)
+ if idx >= 0:
+ # We found the next non-CRLF character.
+ # Set the stream position correctly, then break
+ stream.seek(idx + 1, SEEK_CUR)
+ break
+ # Join all the blocks in the line (which are in reverse order)
+ return b"".join(line_content[::-1])
+
+
+def matrix_multiply(
+ a: TransformationMatrixType, b: TransformationMatrixType
+) -> TransformationMatrixType:
+ return tuple( # type: ignore[return-value]
+ tuple(sum(float(i) * float(j) for i, j in zip(row, col)) for col in zip(*b))
+ for row in a
+ )
+
+
+def mark_location(stream: StreamType) -> None:
+ """Create text file showing current location in context."""
+ # Mainly for debugging
+ radius = 5000
+ stream.seek(-radius, 1)
+ with open("pypdf_pdfLocation.txt", "wb") as output_fh:
+ output_fh.write(stream.read(radius))
+ output_fh.write(b"HERE")
+ output_fh.write(stream.read(radius))
+ stream.seek(-radius, 1)
+
+
+@overload
+def ord_(b: str) -> int:
+ ...
+
+
+@overload
+def ord_(b: bytes) -> bytes:
+ ...
+
+
+@overload
+def ord_(b: int) -> int:
+ ...
+
+
+def ord_(b: Union[int, str, bytes]) -> Union[int, bytes]:
+ if isinstance(b, str):
+ return ord(b)
+ return b
+
+
+def deprecate(msg: str, stacklevel: int = 3) -> None:
+ warnings.warn(msg, DeprecationWarning, stacklevel=stacklevel)
+
+
+def deprecation(msg: str) -> None:
+ raise DeprecationError(msg)
+
+
+def deprecate_with_replacement(old_name: str, new_name: str, removed_in: str) -> None:
+ """Issue a warning that a feature will be removed, but has a replacement."""
+ deprecate(
+ f"{old_name} is deprecated and will be removed in pypdf {removed_in}. Use {new_name} instead.",
+ 4,
+ )
+
+
+def deprecation_with_replacement(old_name: str, new_name: str, removed_in: str) -> None:
+ """Raise an exception that a feature was already removed, but has a replacement."""
+ deprecation(
+ f"{old_name} is deprecated and was removed in pypdf {removed_in}. Use {new_name} instead."
+ )
+
+
+def deprecate_no_replacement(name: str, removed_in: str) -> None:
+ """Issue a warning that a feature will be removed without replacement."""
+ deprecate(f"{name} is deprecated and will be removed in pypdf {removed_in}.", 4)
+
+
+def deprecation_no_replacement(name: str, removed_in: str) -> None:
+ """Raise an exception that a feature was already removed without replacement."""
+ deprecation(f"{name} is deprecated and was removed in pypdf {removed_in}.")
+
+
+def logger_error(msg: str, src: str) -> None:
+ """
+ Use this instead of logger.error directly.
+
+ That allows people to overwrite it more easily.
+
+ See the docs on when to use which:
+ https://pypdf.readthedocs.io/en/latest/user/suppress-warnings.html
+ """
+ logging.getLogger(src).error(msg)
+
+
+def logger_warning(msg: str, src: str) -> None:
+ """
+ Use this instead of logger.warning directly.
+
+ That allows people to overwrite it more easily.
+
+ ## Exception, warnings.warn, logger_warning
+ - Exceptions should be used if the user should write code that deals with
+ an error case, e.g. the PDF being completely broken.
+ - warnings.warn should be used if the user needs to fix their code, e.g.
+ DeprecationWarnings
+ - logger_warning should be used if the user needs to know that an issue was
+ handled by pypdf, e.g. a non-compliant PDF being read in a way that
+ pypdf could apply a robustness fix to still read it. This applies mainly
+ to strict=False mode.
+ """
+ logging.getLogger(src).warning(msg)
+
+
+def rename_kwargs(
+ func_name: str, kwargs: dict[str, Any], aliases: dict[str, str], fail: bool = False
+) -> None:
+ """
+ Helper function to deprecate arguments.
+
+ Args:
+ func_name: Name of the function to be deprecated
+ kwargs:
+ aliases:
+ fail:
+
+ """
+ for old_term, new_term in aliases.items():
+ if old_term in kwargs:
+ if fail:
+ raise DeprecationError(
+ f"{old_term} is deprecated as an argument. Use {new_term} instead"
+ )
+ if new_term in kwargs:
+ raise TypeError(
+ f"{func_name} received both {old_term} and {new_term} as "
+ f"an argument. {old_term} is deprecated. "
+ f"Use {new_term} instead."
+ )
+ kwargs[new_term] = kwargs.pop(old_term)
+ warnings.warn(
+ message=(
+ f"{old_term} is deprecated as an argument. Use {new_term} instead"
+ ),
+ category=DeprecationWarning,
+ stacklevel=3,
+ )
+
+
+def _human_readable_bytes(bytes: int) -> str:
+ if bytes < 10**3:
+ return f"{bytes} Byte"
+ if bytes < 10**6:
+ return f"{bytes / 10**3:.1f} kB"
+ if bytes < 10**9:
+ return f"{bytes / 10**6:.1f} MB"
+ return f"{bytes / 10**9:.1f} GB"
+
+
+# The following class has been copied from Django:
+# https://github.com/django/django/blob/adae619426b6f50046b3daaa744db52989c9d6db/django/utils/functional.py#L51-L65
+# It received some modifications to comply with our own coding standards.
+#
+# Original license:
+#
+# ---------------------------------------------------------------------------------
+# Copyright (c) Django Software Foundation and individual contributors.
+# 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 Django nor the names of its contributors may be used
+# to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+# ---------------------------------------------------------------------------------
+class classproperty: # noqa: N801
+ """
+ Decorator that converts a method with a single cls argument into a property
+ that can be accessed directly from the class.
+ """
+
+ def __init__(self, method=None) -> None: # type: ignore # noqa: ANN001
+ self.fget = method
+
+ def __get__(self, instance, cls=None) -> Any: # type: ignore # noqa: ANN001
+ return self.fget(cls)
+
+ def getter(self, method) -> Self: # type: ignore # noqa: ANN001
+ self.fget = method
+ return self
+
+
+@dataclass
+class File:
+ from .generic import IndirectObject # noqa: PLC0415
+
+ name: str = ""
+ """
+ Filename as identified within the PDF file.
+ """
+ data: bytes = b""
+ """
+ Data as bytes.
+ """
+ indirect_reference: Optional[IndirectObject] = None
+ """
+ Reference to the object storing the stream.
+ """
+
+ def __str__(self) -> str:
+ return f"{self.__class__.__name__}(name={self.name}, data: {_human_readable_bytes(len(self.data))})"
+
+ def __repr__(self) -> str:
+ return self.__str__()[:-1] + f", hash: {hash(self.data)})"
+
+
+@functools.total_ordering
+class Version:
+ COMPONENT_PATTERN = re.compile(r"^(\d+)(.*)$")
+
+ def __init__(self, version_str: str) -> None:
+ self.version_str = version_str
+ self.components = self._parse_version(version_str)
+
+ def _parse_version(self, version_str: str) -> list[tuple[int, str]]:
+ components = version_str.split(".")
+ parsed_components = []
+ for component in components:
+ match = Version.COMPONENT_PATTERN.match(component)
+ if not match:
+ parsed_components.append((0, component))
+ continue
+ integer_prefix = match.group(1)
+ suffix = match.group(2)
+ if integer_prefix is None:
+ integer_prefix = 0
+ parsed_components.append((int(integer_prefix), suffix))
+ return parsed_components
+
+ def __eq__(self, other: object) -> bool:
+ if not isinstance(other, Version):
+ return False
+ return self.components == other.components
+
+ def __hash__(self) -> int:
+ # Convert to tuple as lists cannot be hashed.
+ return hash((self.__class__, tuple(self.components)))
+
+ def __lt__(self, other: Any) -> bool:
+ if not isinstance(other, Version):
+ raise ValueError(f"Version cannot be compared against {type(other)}")
+
+ for self_component, other_component in zip(self.components, other.components):
+ self_value, self_suffix = self_component
+ other_value, other_suffix = other_component
+
+ if self_value < other_value:
+ return True
+ if self_value > other_value:
+ return False
+
+ if self_suffix < other_suffix:
+ return True
+ if self_suffix > other_suffix:
+ return False
+
+ return len(self.components) < len(other.components)
diff --git a/venv/lib/python3.12/site-packages/pypdf/_version.py b/venv/lib/python3.12/site-packages/pypdf/_version.py
new file mode 100644
index 0000000..780e19e
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_version.py
@@ -0,0 +1 @@
+__version__ = "6.6.2"
diff --git a/venv/lib/python3.12/site-packages/pypdf/_writer.py b/venv/lib/python3.12/site-packages/pypdf/_writer.py
new file mode 100644
index 0000000..3c26e20
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_writer.py
@@ -0,0 +1,3307 @@
+# Copyright (c) 2006, Mathieu Fenniak
+# Copyright (c) 2007, Ashish Kulkarni
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+
+import decimal
+import enum
+import hashlib
+import re
+import struct
+import uuid
+from collections.abc import Iterable, Mapping
+from io import BytesIO, FileIO, IOBase
+from itertools import compress
+from pathlib import Path
+from re import Pattern
+from types import TracebackType
+from typing import (
+ IO,
+ Any,
+ Callable,
+ Optional,
+ Union,
+ cast,
+)
+
+from ._doc_common import DocumentInformation, PdfDocCommon
+from ._encryption import EncryptAlgorithm, Encryption
+from ._page import PageObject, Transformation
+from ._page_labels import nums_clear_range, nums_insert, nums_next
+from ._reader import PdfReader
+from ._utils import (
+ StrByteType,
+ StreamType,
+ _get_max_pdf_version_header,
+ deprecation_no_replacement,
+ logger_warning,
+)
+from .constants import AnnotationDictionaryAttributes as AA
+from .constants import CatalogAttributes as CA
+from .constants import (
+ CatalogDictionary,
+ GoToActionArguments,
+ ImageType,
+ InteractiveFormDictEntries,
+ OutlineFontFlag,
+ PageLabelStyle,
+ PagesAttributes,
+ TypFitArguments,
+ UserAccessPermissions,
+)
+from .constants import Core as CO
+from .constants import FieldDictionaryAttributes as FA
+from .constants import PageAttributes as PG
+from .constants import TrailerKeys as TK
+from .errors import PdfReadError, PyPdfError
+from .generic import (
+ PAGE_FIT,
+ ArrayObject,
+ BooleanObject,
+ ByteStringObject,
+ ContentStream,
+ Destination,
+ DictionaryObject,
+ EmbeddedFile,
+ Fit,
+ FloatObject,
+ IndirectObject,
+ NameObject,
+ NullObject,
+ NumberObject,
+ PdfObject,
+ RectangleObject,
+ ReferenceLink,
+ StreamObject,
+ TextStringObject,
+ TreeObject,
+ ViewerPreferences,
+ create_string_object,
+ extract_links,
+ hex_to_rgb,
+ is_null_or_none,
+)
+from .generic._appearance_stream import TextStreamAppearance
+from .pagerange import PageRange, PageRangeSpec
+from .types import (
+ AnnotationSubtype,
+ BorderArrayType,
+ LayoutType,
+ OutlineItemType,
+ OutlineType,
+ PagemodeType,
+)
+from .xmp import XmpInformation
+
+ALL_DOCUMENT_PERMISSIONS = UserAccessPermissions.all()
+
+
+class ObjectDeletionFlag(enum.IntFlag):
+ NONE = 0
+ TEXT = enum.auto()
+ LINKS = enum.auto()
+ ATTACHMENTS = enum.auto()
+ OBJECTS_3D = enum.auto()
+ ALL_ANNOTATIONS = enum.auto()
+ XOBJECT_IMAGES = enum.auto()
+ INLINE_IMAGES = enum.auto()
+ DRAWING_IMAGES = enum.auto()
+ IMAGES = XOBJECT_IMAGES | INLINE_IMAGES | DRAWING_IMAGES
+
+
+def _rolling_checksum(stream: BytesIO, blocksize: int = 65536) -> str:
+ hash = hashlib.md5(usedforsecurity=False)
+ for block in iter(lambda: stream.read(blocksize), b""):
+ hash.update(block)
+ return hash.hexdigest()
+
+
+class PdfWriter(PdfDocCommon):
+ """
+ Write a PDF file out, given pages produced by another class or through
+ cloning a PDF file during initialization.
+
+ Typically data is added from a :class:`PdfReader`.
+
+ Args:
+ clone_from: identical to fileobj (for compatibility)
+
+ incremental: If true, loads the document and set the PdfWriter in incremental mode.
+
+ When writing incrementally, the original document is written first and new/modified
+ content is appended. To be used for signed document/forms to keep signature valid.
+
+ full: If true, loads all the objects (always full if incremental = True).
+ This parameter may allow loading large PDFs.
+
+ strict: If true, pypdf will raise an exception if a PDF does not follow the specification.
+ If false, pypdf will try to be forgiving and do something reasonable, but it will log
+ a warning message. It is a best-effort approach.
+
+ """
+
+ def __init__(
+ self,
+ fileobj: Union[None, PdfReader, StrByteType, Path] = "",
+ clone_from: Union[None, PdfReader, StrByteType, Path] = None,
+ incremental: bool = False,
+ full: bool = False,
+ strict: bool = False,
+ ) -> None:
+ self.strict = strict
+ """
+ If true, pypdf will raise an exception if a PDF does not follow the specification.
+ If false, pypdf will try to be forgiving and do something reasonable, but it will log
+ a warning message. It is a best-effort approach.
+ """
+
+ self.incremental = incremental or full
+ """
+ Returns if the PdfWriter object has been started in incremental mode.
+ """
+
+ self._objects: list[Optional[PdfObject]] = []
+ """
+ The indirect objects in the PDF.
+ For the incremental case, it will be filled with None
+ in clone_reader_document_root.
+ """
+
+ self._original_hash: list[int] = []
+ """
+ List of hashes after import; used to identify changes.
+ """
+
+ self._idnum_hash: dict[bytes, tuple[IndirectObject, list[IndirectObject]]] = {}
+ """
+ Maps hash values of indirect objects to the list of IndirectObjects.
+ This is used for compression.
+ """
+
+ self._id_translated: dict[int, dict[int, int]] = {}
+ """List of already translated IDs.
+ dict[id(pdf)][(idnum, generation)]
+ """
+
+ self._info_obj: Optional[PdfObject]
+ """The PDF files's document information dictionary,
+ defined by Info in the PDF file's trailer dictionary."""
+
+ self._ID: Union[ArrayObject, None] = None
+ """The PDF file identifier,
+ defined by the ID in the PDF file's trailer dictionary."""
+
+ self._unresolved_links: list[tuple[ReferenceLink, ReferenceLink]] = []
+ "Tracks links in pages added to the writer for resolving later."
+ self._merged_in_pages: dict[Optional[IndirectObject], Optional[IndirectObject]] = {}
+ "Tracks pages added to the writer and what page they turned into."
+
+ if self.incremental:
+ if isinstance(fileobj, (str, Path)):
+ with open(fileobj, "rb") as f:
+ fileobj = BytesIO(f.read(-1))
+ if isinstance(fileobj, BytesIO):
+ fileobj = PdfReader(fileobj)
+ if not isinstance(fileobj, PdfReader):
+ raise PyPdfError("Invalid type for incremental mode")
+ self._reader = fileobj # prev content is in _reader.stream
+ self._header = fileobj.pdf_header.encode()
+ self._readonly = True # TODO: to be analysed
+ else:
+ self._header = b"%PDF-1.3"
+ self._info_obj = self._add_object(
+ DictionaryObject(
+ {NameObject("/Producer"): create_string_object("pypdf")}
+ )
+ )
+
+ def _get_clone_from(
+ fileobj: Union[None, PdfReader, str, Path, IO[Any], BytesIO],
+ clone_from: Union[None, PdfReader, str, Path, IO[Any], BytesIO],
+ ) -> Union[None, PdfReader, str, Path, IO[Any], BytesIO]:
+ if isinstance(fileobj, (str, Path, IO, BytesIO)) and (
+ fileobj == "" or clone_from is not None
+ ):
+ return clone_from
+ cloning = True
+ if isinstance(fileobj, (str, Path)) and (
+ not Path(str(fileobj)).exists()
+ or Path(str(fileobj)).stat().st_size == 0
+ ):
+ cloning = False
+ if isinstance(fileobj, (IOBase, BytesIO)):
+ t = fileobj.tell()
+ if fileobj.seek(0, 2) == 0:
+ cloning = False
+ fileobj.seek(t, 0)
+ if cloning:
+ clone_from = fileobj
+ return clone_from
+
+ clone_from = _get_clone_from(fileobj, clone_from)
+ # To prevent overwriting
+ self.temp_fileobj = fileobj
+ self.fileobj = ""
+ self._with_as_usage = False
+ self._cloned = False
+ # The root of our page tree node
+ pages = DictionaryObject(
+ {
+ NameObject(PagesAttributes.TYPE): NameObject("/Pages"),
+ NameObject(PagesAttributes.COUNT): NumberObject(0),
+ NameObject(PagesAttributes.KIDS): ArrayObject(),
+ }
+ )
+ self.flattened_pages = []
+ self._encryption: Optional[Encryption] = None
+ self._encrypt_entry: Optional[DictionaryObject] = None
+
+ if clone_from is not None:
+ if not isinstance(clone_from, PdfReader):
+ clone_from = PdfReader(clone_from)
+ self.clone_document_from_reader(clone_from)
+ self._cloned = True
+ else:
+ self._pages = self._add_object(pages)
+ self._root_object = DictionaryObject(
+ {
+ NameObject(PagesAttributes.TYPE): NameObject(CO.CATALOG),
+ NameObject(CO.PAGES): self._pages,
+ }
+ )
+ self._add_object(self._root_object)
+ if full and not incremental:
+ self.incremental = False
+ if isinstance(self._ID, list):
+ if isinstance(self._ID[0], TextStringObject):
+ self._ID[0] = ByteStringObject(self._ID[0].get_original_bytes())
+ if isinstance(self._ID[1], TextStringObject):
+ self._ID[1] = ByteStringObject(self._ID[1].get_original_bytes())
+
+ # for commonality
+ @property
+ def is_encrypted(self) -> bool:
+ """
+ Read-only boolean property showing whether this PDF file is encrypted.
+
+ Note that this property, if true, will remain true even after the
+ :meth:`decrypt()` method is called.
+ """
+ return False
+
+ @property
+ def root_object(self) -> DictionaryObject:
+ """
+ Provide direct access to PDF Structure.
+
+ Note:
+ Recommended only for read access.
+
+ """
+ return self._root_object
+
+ @property
+ def _info(self) -> Optional[DictionaryObject]:
+ """
+ Provide access to "/Info". Standardized with PdfReader.
+
+ Returns:
+ /Info Dictionary; None if the entry does not exist
+
+ """
+ return (
+ None
+ if self._info_obj is None
+ else cast(DictionaryObject, self._info_obj.get_object())
+ )
+
+ @_info.setter
+ def _info(self, value: Optional[Union[IndirectObject, DictionaryObject]]) -> None:
+ if value is None:
+ try:
+ self._objects[self._info_obj.indirect_reference.idnum - 1] = None # type: ignore
+ except (KeyError, AttributeError):
+ pass
+ self._info_obj = None
+ else:
+ if self._info_obj is None:
+ self._info_obj = self._add_object(DictionaryObject())
+ obj = cast(DictionaryObject, self._info_obj.get_object())
+ obj.clear()
+ obj.update(cast(DictionaryObject, value.get_object()))
+
+ @property
+ def xmp_metadata(self) -> Optional[XmpInformation]:
+ """XMP (Extensible Metadata Platform) data."""
+ return cast(XmpInformation, self.root_object.xmp_metadata)
+
+ @xmp_metadata.setter
+ def xmp_metadata(self, value: Union[XmpInformation, bytes, None]) -> None:
+ """XMP (Extensible Metadata Platform) data."""
+ if value is None:
+ if "/Metadata" in self.root_object:
+ del self.root_object["/Metadata"]
+ return
+
+ metadata = self.root_object.get("/Metadata", None)
+ if not isinstance(metadata, IndirectObject):
+ if metadata is not None:
+ del self.root_object["/Metadata"]
+ metadata_stream = StreamObject()
+ stream_reference = self._add_object(metadata_stream)
+ self.root_object[NameObject("/Metadata")] = stream_reference
+ else:
+ metadata_stream = cast(StreamObject, metadata.get_object())
+
+ if isinstance(value, XmpInformation):
+ bytes_data = value.stream.get_data()
+ else:
+ bytes_data = value
+ metadata_stream.set_data(bytes_data)
+
+ @property
+ def with_as_usage(self) -> bool:
+ deprecation_no_replacement("with_as_usage", "5.0")
+ return self._with_as_usage
+
+ @with_as_usage.setter
+ def with_as_usage(self, value: bool) -> None:
+ deprecation_no_replacement("with_as_usage", "5.0")
+ self._with_as_usage = value
+
+ def __enter__(self) -> "PdfWriter":
+ """Store how writer is initialized by 'with'."""
+ c: bool = self._cloned
+ t = self.temp_fileobj
+ self.__init__() # type: ignore
+ self._cloned = c
+ self._with_as_usage = True
+ self.fileobj = t # type: ignore
+ return self
+
+ def __exit__(
+ self,
+ exc_type: Optional[type[BaseException]],
+ exc: Optional[BaseException],
+ traceback: Optional[TracebackType],
+ ) -> None:
+ """Write data to the fileobj."""
+ if self.fileobj and not self._cloned:
+ self.write(self.fileobj)
+
+ @property
+ def pdf_header(self) -> str:
+ """
+ Read/Write property of the PDF header that is written.
+
+ This should be something like ``'%PDF-1.5'``. It is recommended to set
+ the lowest version that supports all features which are used within the
+ PDF file.
+
+ Note: `pdf_header` returns a string but accepts bytes or str for writing
+ """
+ return self._header.decode()
+
+ @pdf_header.setter
+ def pdf_header(self, new_header: Union[str, bytes]) -> None:
+ if isinstance(new_header, str):
+ new_header = new_header.encode()
+ self._header = new_header
+
+ def _add_object(self, obj: PdfObject) -> IndirectObject:
+ if (
+ getattr(obj, "indirect_reference", None) is not None
+ and obj.indirect_reference.pdf == self # type: ignore
+ ):
+ return obj.indirect_reference # type: ignore
+ # check for /Contents in Pages (/Contents in annotations are strings)
+ if isinstance(obj, DictionaryObject) and isinstance(
+ obj.get(PG.CONTENTS, None), (ArrayObject, DictionaryObject)
+ ):
+ obj[NameObject(PG.CONTENTS)] = self._add_object(obj[PG.CONTENTS])
+ self._objects.append(obj)
+ obj.indirect_reference = IndirectObject(len(self._objects), 0, self)
+ return obj.indirect_reference
+
+ def get_object(
+ self,
+ indirect_reference: Union[int, IndirectObject],
+ ) -> PdfObject:
+ if isinstance(indirect_reference, int):
+ obj = self._objects[indirect_reference - 1]
+ elif indirect_reference.pdf != self:
+ raise ValueError("PDF must be self")
+ else:
+ obj = self._objects[indirect_reference.idnum - 1]
+ assert obj is not None, "mypy"
+ return obj
+
+ def _replace_object(
+ self,
+ indirect_reference: Union[int, IndirectObject],
+ obj: PdfObject,
+ ) -> PdfObject:
+ if isinstance(indirect_reference, IndirectObject):
+ if indirect_reference.pdf != self:
+ raise ValueError("PDF must be self")
+ indirect_reference = indirect_reference.idnum
+ gen = self._objects[indirect_reference - 1].indirect_reference.generation # type: ignore
+ if (
+ getattr(obj, "indirect_reference", None) is not None
+ and obj.indirect_reference.pdf != self # type: ignore
+ ):
+ obj = obj.clone(self)
+ self._objects[indirect_reference - 1] = obj
+ obj.indirect_reference = IndirectObject(indirect_reference, gen, self)
+
+ assert isinstance(obj, PdfObject), "mypy"
+ return obj
+
+ def _add_page(
+ self,
+ page: PageObject,
+ index: int,
+ excluded_keys: Iterable[str] = (),
+ ) -> PageObject:
+ if not isinstance(page, PageObject) or page.get(PagesAttributes.TYPE, None) != CO.PAGE:
+ raise ValueError("Invalid page object")
+ assert self.flattened_pages is not None, "for mypy"
+ page_org = page
+ excluded_keys = list(excluded_keys)
+ excluded_keys += [PagesAttributes.PARENT, "/StructParents"]
+ # Acrobat does not accept two indirect references pointing on the same
+ # page; therefore in order to add multiple copies of the same
+ # page, we need to create a new dictionary for the page, however the
+ # objects below (including content) are not duplicated:
+ try: # delete an already existing page
+ del self._id_translated[id(page_org.indirect_reference.pdf)][ # type: ignore
+ page_org.indirect_reference.idnum # type: ignore
+ ]
+ except Exception:
+ pass
+
+ page = cast(
+ "PageObject", page_org.clone(self, False, excluded_keys).get_object()
+ )
+ if page_org.pdf is not None:
+ other = page_org.pdf.pdf_header
+ self.pdf_header = _get_max_pdf_version_header(self.pdf_header, other)
+
+ node, idx = self._get_page_in_node(index)
+ page[NameObject(PagesAttributes.PARENT)] = node.indirect_reference
+
+ if idx >= 0:
+ cast(ArrayObject, node[PagesAttributes.KIDS]).insert(idx, page.indirect_reference)
+ self.flattened_pages.insert(index, page)
+ else:
+ cast(ArrayObject, node[PagesAttributes.KIDS]).append(page.indirect_reference)
+ self.flattened_pages.append(page)
+ recurse = 0
+ while not is_null_or_none(node):
+ node = cast(DictionaryObject, node.get_object())
+ node[NameObject(PagesAttributes.COUNT)] = NumberObject(cast(int, node[PagesAttributes.COUNT]) + 1)
+ node = node.get(PagesAttributes.PARENT, None) # type: ignore[assignment] # TODO: Fix.
+ recurse += 1
+ if recurse > 1000:
+ raise PyPdfError("Too many recursive calls!")
+
+ if page_org.pdf is not None:
+ # the page may contain links to other pages, and those other
+ # pages may or may not already be added. we store the
+ # information we need, so that we can resolve the references
+ # later.
+ self._unresolved_links.extend(extract_links(page, page_org))
+ self._merged_in_pages[page_org.indirect_reference] = page.indirect_reference
+
+ return page
+
+ def set_need_appearances_writer(self, state: bool = True) -> None:
+ """
+ Sets the "NeedAppearances" flag in the PDF writer.
+
+ The "NeedAppearances" flag indicates whether the appearance dictionary
+ for form fields should be automatically generated by the PDF viewer or
+ if the embedded appearance should be used.
+
+ Args:
+ state: The actual value of the NeedAppearances flag.
+
+ Returns:
+ None
+
+ """
+ # See §12.7.2 and §7.7.2 for more information:
+ # https://opensource.adobe.com/dc-acrobat-sdk-docs/pdfstandards/PDF32000_2008.pdf
+ try:
+ # get the AcroForm tree
+ if CatalogDictionary.ACRO_FORM not in self._root_object:
+ self._root_object[
+ NameObject(CatalogDictionary.ACRO_FORM)
+ ] = self._add_object(DictionaryObject())
+
+ need_appearances = NameObject(InteractiveFormDictEntries.NeedAppearances)
+ cast(DictionaryObject, self._root_object[CatalogDictionary.ACRO_FORM])[
+ need_appearances
+ ] = BooleanObject(state)
+ except Exception as exc: # pragma: no cover
+ logger_warning(
+ f"set_need_appearances_writer({state}) catch : {exc}", __name__
+ )
+
+ def create_viewer_preferences(self) -> ViewerPreferences:
+ o = ViewerPreferences()
+ self._root_object[
+ NameObject(CatalogDictionary.VIEWER_PREFERENCES)
+ ] = self._add_object(o)
+ return o
+
+ def add_page(
+ self,
+ page: PageObject,
+ excluded_keys: Iterable[str] = (),
+ ) -> PageObject:
+ """
+ Add a page to this PDF file.
+
+ Recommended for advanced usage including the adequate excluded_keys.
+
+ The page is usually acquired from a :class:`PdfReader`
+ instance.
+
+ Args:
+ page: The page to add to the document. Should be
+ an instance of :class:`PageObject`
+ excluded_keys:
+
+ Returns:
+ The added PageObject.
+
+ """
+ assert self.flattened_pages is not None, "mypy"
+ return self._add_page(page, len(self.flattened_pages), excluded_keys)
+
+ def insert_page(
+ self,
+ page: PageObject,
+ index: int = 0,
+ excluded_keys: Iterable[str] = (),
+ ) -> PageObject:
+ """
+ Insert a page in this PDF file. The page is usually acquired from a
+ :class:`PdfReader` instance.
+
+ Args:
+ page: The page to add to the document.
+ index: Position at which the page will be inserted.
+ excluded_keys:
+
+ Returns:
+ The added PageObject.
+
+ """
+ assert self.flattened_pages is not None, "mypy"
+ if index < 0:
+ index += len(self.flattened_pages)
+ if index < 0:
+ raise ValueError("Invalid index value")
+ if index >= len(self.flattened_pages):
+ return self.add_page(page, excluded_keys)
+ return self._add_page(page, index, excluded_keys)
+
+ def _get_page_number_by_indirect(
+ self, indirect_reference: Union[None, int, NullObject, IndirectObject]
+ ) -> Optional[int]:
+ """
+ Generate _page_id2num.
+
+ Args:
+ indirect_reference:
+
+ Returns:
+ The page number or None
+
+ """
+ # To provide same function as in PdfReader
+ if is_null_or_none(indirect_reference):
+ return None
+ assert indirect_reference is not None, "mypy"
+ if isinstance(indirect_reference, int):
+ indirect_reference = IndirectObject(indirect_reference, 0, self)
+ obj = indirect_reference.get_object()
+ if isinstance(obj, PageObject):
+ return obj.page_number
+ return None
+
+ def add_blank_page(
+ self, width: Optional[float] = None, height: Optional[float] = None
+ ) -> PageObject:
+ """
+ Append a blank page to this PDF file and return it.
+
+ If no page size is specified, use the size of the last page.
+
+ Args:
+ width: The width of the new page expressed in default user
+ space units.
+ height: The height of the new page expressed in default
+ user space units.
+
+ Returns:
+ The newly appended page.
+
+ Raises:
+ PageSizeNotDefinedError: if width and height are not defined
+ and previous page does not exist.
+
+ """
+ page = PageObject.create_blank_page(self, width, height)
+ return self.add_page(page)
+
+ def insert_blank_page(
+ self,
+ width: Optional[Union[float, decimal.Decimal]] = None,
+ height: Optional[Union[float, decimal.Decimal]] = None,
+ index: int = 0,
+ ) -> PageObject:
+ """
+ Insert a blank page to this PDF file and return it.
+
+ If no page size is specified for a dimension, use the size of the last page.
+
+ Args:
+ width: The width of the new page expressed in default user
+ space units.
+ height: The height of the new page expressed in default
+ user space units.
+ index: Position to add the page.
+
+ Returns:
+ The newly inserted page.
+
+ Raises:
+ PageSizeNotDefinedError: if width and height are not defined
+ and previous page does not exist.
+
+ """
+ if width is None or (height is None and index < self.get_num_pages()):
+ oldpage = self.pages[index]
+ width = oldpage.mediabox.width
+ height = oldpage.mediabox.height
+ page = PageObject.create_blank_page(self, width, height)
+ self.insert_page(page, index)
+ return page
+
+ @property
+ def open_destination(
+ self,
+ ) -> Union[None, Destination, TextStringObject, ByteStringObject]:
+ return super().open_destination
+
+ @open_destination.setter
+ def open_destination(self, dest: Union[None, str, Destination, PageObject]) -> None:
+ if dest is None:
+ try:
+ del self._root_object["/OpenAction"]
+ except KeyError:
+ pass
+ elif isinstance(dest, str):
+ self._root_object[NameObject("/OpenAction")] = TextStringObject(dest)
+ elif isinstance(dest, Destination):
+ self._root_object[NameObject("/OpenAction")] = dest.dest_array
+ elif isinstance(dest, PageObject):
+ self._root_object[NameObject("/OpenAction")] = Destination(
+ "Opening",
+ dest.indirect_reference
+ if dest.indirect_reference is not None
+ else NullObject(),
+ PAGE_FIT,
+ ).dest_array
+
+ def add_js(self, javascript: str) -> None:
+ """
+ Add JavaScript which will launch upon opening this PDF.
+
+ Args:
+ javascript: Your JavaScript.
+
+ Example:
+ This will launch the print window when the PDF is opened.
+
+ >>> from pypdf import PdfWriter
+ >>> output = PdfWriter()
+ >>> output.add_js("this.print({bUI:true,bSilent:false,bShrinkToFit:true});")
+
+ """
+ # Names / JavaScript preferred to be able to add multiple scripts
+ if "/Names" not in self._root_object:
+ self._root_object[NameObject(CA.NAMES)] = DictionaryObject()
+ names = cast(DictionaryObject, self._root_object[CA.NAMES])
+ if "/JavaScript" not in names:
+ names[NameObject("/JavaScript")] = DictionaryObject(
+ {NameObject("/Names"): ArrayObject()}
+ )
+ js_list = cast(
+ ArrayObject, cast(DictionaryObject, names["/JavaScript"])["/Names"]
+ )
+ # We need a name for parameterized JavaScript in the PDF file,
+ # but it can be anything.
+ js_list.append(create_string_object(str(uuid.uuid4())))
+
+ js = DictionaryObject(
+ {
+ NameObject(PagesAttributes.TYPE): NameObject("/Action"),
+ NameObject("/S"): NameObject("/JavaScript"),
+ NameObject("/JS"): TextStringObject(f"{javascript}"),
+ }
+ )
+ js_list.append(self._add_object(js))
+
+ def add_attachment(self, filename: str, data: Union[str, bytes]) -> "EmbeddedFile":
+ """
+ Embed a file inside the PDF.
+
+ Reference:
+ https://opensource.adobe.com/dc-acrobat-sdk-docs/pdfstandards/PDF32000_2008.pdf
+ Section 7.11.3
+
+ Args:
+ filename: The filename to display.
+ data: The data in the file.
+
+ Returns:
+ EmbeddedFile instance for the newly created embedded file.
+
+ """
+ return EmbeddedFile._create_new(self, filename, data)
+
+ def append_pages_from_reader(
+ self,
+ reader: PdfReader,
+ after_page_append: Optional[Callable[[PageObject], None]] = None,
+ ) -> None:
+ """
+ Copy pages from reader to writer. Includes an optional callback
+ parameter which is invoked after pages are appended to the writer.
+
+ ``append`` should be preferred.
+
+ Args:
+ reader: a PdfReader object from which to copy page
+ annotations to this writer object. The writer's annots
+ will then be updated.
+ after_page_append:
+ Callback function that is invoked after each page is appended to
+ the writer. Signature includes a reference to the appended page
+ (delegates to append_pages_from_reader). The single parameter of
+ the callback is a reference to the page just appended to the
+ document.
+
+ """
+ reader_num_pages = len(reader.pages)
+ # Copy pages from reader to writer
+ for reader_page_number in range(reader_num_pages):
+ reader_page = reader.pages[reader_page_number]
+ writer_page = self.add_page(reader_page)
+ # Trigger callback, pass writer page as parameter
+ if callable(after_page_append):
+ after_page_append(writer_page)
+
+ def _merge_content_stream_to_page(
+ self,
+ page: PageObject,
+ new_content_data: bytes,
+ ) -> None:
+ """
+ Combines existing content stream(s) with new content (as bytes).
+
+ Args:
+ page: The page to which the new content data will be added.
+ new_content_data: A binary-encoded new content stream, for
+ instance the commands to draw an XObject.
+ """
+ # First resolve the existing page content. This always is an IndirectObject:
+ # PDF Explained by John Whitington
+ # https://www.oreilly.com/library/view/pdf-explained/9781449321581/ch04.html
+ if NameObject("/Contents") in page:
+ existing_content_ref = page[NameObject("/Contents")]
+ existing_content = existing_content_ref.get_object()
+
+ if isinstance(existing_content, ArrayObject):
+ # Create a new StreamObject for the new_content_data
+ new_stream_obj = StreamObject()
+ new_stream_obj.set_data(new_content_data)
+ existing_content.append(self._add_object(new_stream_obj))
+ page[NameObject("/Contents")] = self._add_object(existing_content)
+ if isinstance(existing_content, StreamObject):
+ # Merge new content to existing StreamObject
+ merged_data = existing_content.get_data() + b"\n" + new_content_data
+ new_stream = StreamObject()
+ new_stream.set_data(merged_data)
+ page[NameObject("/Contents")] = self._add_object(new_stream)
+ else:
+ # If no existing content, then we have an empty page.
+ # Create a new StreamObject in a new /Contents entry.
+ new_stream = StreamObject()
+ new_stream.set_data(new_content_data)
+ page[NameObject("/Contents")] = self._add_object(new_stream)
+
+ def _add_apstream_object(
+ self,
+ page: PageObject,
+ appearance_stream_obj: StreamObject,
+ object_name: str,
+ x_offset: float,
+ y_offset: float,
+ ) -> None:
+ """
+ Adds an appearance stream to the page content in the form of
+ an XObject.
+
+ Args:
+ page: The page to which to add the appearance stream.
+ appearance_stream_obj: The appearance stream.
+ object_name: The name of the appearance stream.
+ x_offset: The horizontal offset for the appearance stream.
+ y_offset: The vertical offset for the appearance stream.
+ """
+ # Prepare XObject resource dictionary on the page. This currently
+ # only deals with font resources, but can easily be adapted to also
+ # include other resources.
+ pg_res = cast(DictionaryObject, page[PG.RESOURCES])
+ if "/Resources" in appearance_stream_obj:
+ ap_stream_res = cast(DictionaryObject, appearance_stream_obj["/Resources"])
+ ap_stream_font_dict = cast(DictionaryObject, ap_stream_res.get("/Font", DictionaryObject()))
+ if "/Font" not in pg_res:
+ pg_res[NameObject("/Font")] = DictionaryObject()
+ pg_font_res = cast(DictionaryObject, pg_res["/Font"])
+ # Merge fonts from the appearance stream into the page's font resources
+ for font_name, font_ref in ap_stream_font_dict.items():
+ if font_name not in pg_font_res:
+ pg_font_res[font_name] = font_ref
+ # Always add the resolved stream object to the writer to get a new IndirectObject.
+ # This ensures we have a valid IndirectObject managed by *this* writer.
+ xobject_ref = self._add_object(appearance_stream_obj)
+ xobject_name = NameObject(f"/Fm_{object_name}")._sanitize()
+ if "/XObject" not in pg_res:
+ pg_res[NameObject("/XObject")] = DictionaryObject()
+ pg_xo_res = cast(DictionaryObject, pg_res["/XObject"])
+ if xobject_name not in pg_xo_res:
+ pg_xo_res[xobject_name] = xobject_ref
+ else:
+ logger_warning(
+ f"XObject {xobject_name!r} already added to page resources. This might be an issue.",
+ __name__
+ )
+ xobject_cm = Transformation().translate(x_offset, y_offset)
+ xobject_drawing_commands = f"q\n{xobject_cm._to_cm()}\n{xobject_name} Do\nQ".encode()
+ self._merge_content_stream_to_page(page, xobject_drawing_commands)
+
+ FFBITS_NUL = FA.FfBits(0)
+
+ def update_page_form_field_values(
+ self,
+ page: Union[PageObject, list[PageObject], None],
+ fields: Mapping[str, Union[str, list[str], tuple[str, str, float]]],
+ flags: FA.FfBits = FFBITS_NUL,
+ auto_regenerate: Optional[bool] = True,
+ flatten: bool = False,
+ ) -> None:
+ """
+ Update the form field values for a given page from a fields dictionary.
+
+ Copy field texts and values from fields to page.
+ If the field links to a parent object, add the information to the parent.
+
+ Args:
+ page: `PageObject` - references **PDF writer's page** where the
+ annotations and field data will be updated.
+ `List[Pageobject]` - provides list of pages to be processed.
+ `None` - all pages.
+ fields: a Python dictionary of:
+
+ * field names (/T) as keys and text values (/V) as value
+ * field names (/T) as keys and list of text values (/V) for multiple choice list
+ * field names (/T) as keys and tuple of:
+ * text values (/V)
+ * font id (e.g. /F1, the font id must exist)
+ * font size (0 for autosize)
+
+ flags: A set of flags from :class:`~pypdf.constants.FieldDictionaryAttributes.FfBits`.
+
+ auto_regenerate: Set/unset the need_appearances flag;
+ the flag is unchanged if auto_regenerate is None.
+
+ flatten: Whether or not to flatten the annotation. If True, this adds the annotation's
+ appearance stream to the page contents. Note that this option does not remove the
+ annotation itself.
+
+ """
+ if CatalogDictionary.ACRO_FORM not in self._root_object:
+ raise PyPdfError("No /AcroForm dictionary in PDF of PdfWriter Object")
+ acro_form = cast(DictionaryObject, self._root_object[CatalogDictionary.ACRO_FORM])
+ if InteractiveFormDictEntries.Fields not in acro_form:
+ raise PyPdfError("No /Fields dictionary in PDF of PdfWriter Object")
+ if isinstance(auto_regenerate, bool):
+ self.set_need_appearances_writer(auto_regenerate)
+ # Iterate through pages, update field values
+ if page is None:
+ page = list(self.pages)
+ if isinstance(page, list):
+ for p in page:
+ if PG.ANNOTS in p: # just to prevent warnings
+ self.update_page_form_field_values(p, fields, flags, None, flatten=flatten)
+ return
+ if PG.ANNOTS not in page:
+ logger_warning("No fields to update on this page", __name__)
+ return
+ for annotation in page[PG.ANNOTS]: # type: ignore
+ annotation = cast(DictionaryObject, annotation.get_object())
+ if annotation.get("/Subtype", "") != "/Widget":
+ continue
+ if "/FT" in annotation and "/T" in annotation:
+ parent_annotation = annotation
+ else:
+ parent_annotation = annotation.get(
+ PG.PARENT, DictionaryObject()
+ ).get_object()
+
+ for field, value in fields.items():
+ rectangle = cast(RectangleObject, annotation[AA.Rect])
+ if not (
+ self._get_qualified_field_name(parent_annotation) == field
+ or parent_annotation.get("/T", None) == field
+ ):
+ continue
+ if (
+ parent_annotation.get("/FT", None) == "/Ch"
+ and "/I" in parent_annotation
+ ):
+ del parent_annotation["/I"]
+ if flags:
+ annotation[NameObject(FA.Ff)] = NumberObject(flags)
+ # Set the field value
+ if not (value is None and flatten): # Only change values if given by user and not flattening.
+ if isinstance(value, list):
+ lst = ArrayObject(TextStringObject(v) for v in value)
+ parent_annotation[NameObject(FA.V)] = lst
+ elif isinstance(value, tuple):
+ annotation[NameObject(FA.V)] = TextStringObject(
+ value[0],
+ )
+ else:
+ parent_annotation[NameObject(FA.V)] = TextStringObject(value)
+ # Get or create the field's appearance stream object
+ if parent_annotation.get(FA.FT) == "/Btn":
+ # Checkbox button (no /FT found in Radio widgets);
+ # We can find the associated appearance stream object
+ # within the annotation.
+ v = NameObject(value)
+ ap = cast(DictionaryObject, annotation[NameObject(AA.AP)])
+ normal_ap = cast(DictionaryObject, ap["/N"])
+ if v not in normal_ap:
+ v = NameObject("/Off")
+ appearance_stream_obj = normal_ap.get(v)
+ # Other cases will be updated through the for loop
+ annotation[NameObject(AA.AS)] = v
+ annotation[NameObject(FA.V)] = v
+ elif (
+ parent_annotation.get(FA.FT) == "/Tx"
+ or parent_annotation.get(FA.FT) == "/Ch"
+ ):
+ # Textbox; we need to generate the appearance stream object
+ if isinstance(value, tuple):
+ appearance_stream_obj = TextStreamAppearance.from_text_annotation(
+ acro_form, parent_annotation, annotation, value[1], value[2]
+ )
+ else:
+ appearance_stream_obj = TextStreamAppearance.from_text_annotation(
+ acro_form, parent_annotation, annotation
+ )
+ # Add the appearance stream object
+ if AA.AP not in annotation:
+ annotation[NameObject(AA.AP)] = DictionaryObject(
+ {NameObject("/N"): self._add_object(appearance_stream_obj)}
+ )
+ elif "/N" not in (ap:= cast(DictionaryObject, annotation[AA.AP])):
+ cast(DictionaryObject, annotation[NameObject(AA.AP)])[
+ NameObject("/N")
+ ] = self._add_object(appearance_stream_obj)
+ else: # [/AP][/N] exists
+ n = annotation[AA.AP]["/N"].indirect_reference.idnum # type: ignore
+ self._objects[n - 1] = appearance_stream_obj
+ appearance_stream_obj.indirect_reference = IndirectObject(n, 0, self)
+ elif (
+ annotation.get(FA.FT) == "/Sig"
+ ): # deprecated # not implemented yet
+ logger_warning("Signature forms not implemented yet", __name__)
+ if flatten and appearance_stream_obj is not None:
+ self._add_apstream_object(page, appearance_stream_obj, field, rectangle[0], rectangle[1])
+
+ def reattach_fields(
+ self, page: Optional[PageObject] = None
+ ) -> list[DictionaryObject]:
+ """
+ Parse annotations within the page looking for orphan fields and
+ reattach then into the Fields Structure.
+
+ Args:
+ page: page to analyze.
+ If none is provided, all pages will be analyzed.
+
+ Returns:
+ list of reattached fields.
+
+ """
+ lst = []
+ if page is None:
+ for p in self.pages:
+ lst += self.reattach_fields(p)
+ return lst
+
+ try:
+ af = cast(DictionaryObject, self._root_object[CatalogDictionary.ACRO_FORM])
+ except KeyError:
+ af = DictionaryObject()
+ self._root_object[NameObject(CatalogDictionary.ACRO_FORM)] = af
+ try:
+ fields = cast(ArrayObject, af[InteractiveFormDictEntries.Fields])
+ except KeyError:
+ fields = ArrayObject()
+ af[NameObject(InteractiveFormDictEntries.Fields)] = fields
+
+ if "/Annots" not in page:
+ return lst
+ annotations = cast(ArrayObject, page["/Annots"])
+ for idx, annotation in enumerate(annotations):
+ is_indirect = isinstance(annotation, IndirectObject)
+ annotation = cast(DictionaryObject, annotation.get_object())
+ if annotation.get("/Subtype", "") == "/Widget" and "/FT" in annotation:
+ if (
+ "indirect_reference" in annotation.__dict__
+ and annotation.indirect_reference in fields
+ ):
+ continue
+ if not is_indirect:
+ annotations[idx] = self._add_object(annotation)
+ fields.append(annotation.indirect_reference)
+ lst.append(annotation)
+ return lst
+
+ def clone_reader_document_root(self, reader: PdfReader) -> None:
+ """
+ Copy the reader document root to the writer and all sub-elements,
+ including pages, threads, outlines,... For partial insertion, ``append``
+ should be considered.
+
+ Args:
+ reader: PdfReader from which the document root should be copied.
+
+ """
+ self._info_obj = None
+ if self.incremental:
+ self._objects = [None] * (cast(int, reader.trailer["/Size"]) - 1)
+ for i in range(len(self._objects)):
+ o = reader.get_object(i + 1)
+ if o is not None:
+ self._objects[i] = o.replicate(self)
+ else:
+ self._objects.clear()
+ self._root_object = reader.root_object.clone(self)
+ self._pages = self._root_object.raw_get("/Pages")
+
+ if len(self._objects) > cast(int, reader.trailer["/Size"]):
+ if self.strict:
+ raise PdfReadError(
+ f"Object count {len(self._objects)} exceeds defined trailer size {reader.trailer['/Size']}"
+ )
+ logger_warning(
+ f"Object count {len(self._objects)} exceeds defined trailer size {reader.trailer['/Size']}",
+ __name__
+ )
+
+ # must be done here before rewriting
+ if self.incremental:
+ self._original_hash = [
+ (obj.hash_bin() if obj is not None else 0) for obj in self._objects
+ ]
+
+ try:
+ self._flatten()
+ except IndexError:
+ raise PdfReadError("Got index error while flattening.")
+
+ assert self.flattened_pages is not None
+ for p in self.flattened_pages:
+ self._replace_object(cast(IndirectObject, p.indirect_reference).idnum, p)
+ if not self.incremental:
+ p[NameObject("/Parent")] = self._pages
+ if not self.incremental:
+ cast(DictionaryObject, self._pages.get_object())[
+ NameObject("/Kids")
+ ] = ArrayObject([p.indirect_reference for p in self.flattened_pages])
+
+ def clone_document_from_reader(
+ self,
+ reader: PdfReader,
+ after_page_append: Optional[Callable[[PageObject], None]] = None,
+ ) -> None:
+ """
+ Create a copy (clone) of a document from a PDF file reader cloning
+ section '/Root' and '/Info' and '/ID' of the pdf.
+
+ Args:
+ reader: PDF file reader instance from which the clone
+ should be created.
+ after_page_append:
+ Callback function that is invoked after each page is appended to
+ the writer. Signature includes a reference to the appended page
+ (delegates to append_pages_from_reader). The single parameter of
+ the callback is a reference to the page just appended to the
+ document.
+
+ """
+ self.clone_reader_document_root(reader)
+ inf = reader._info
+ if self.incremental:
+ if inf is not None:
+ self._info_obj = cast(
+ IndirectObject, inf.clone(self).indirect_reference
+ )
+ assert isinstance(self._info, DictionaryObject), "for mypy"
+ self._original_hash[
+ self._info_obj.indirect_reference.idnum - 1
+ ] = self._info.hash_bin()
+ elif inf is not None:
+ self._info_obj = self._add_object(
+ DictionaryObject(cast(DictionaryObject, inf.get_object()))
+ )
+ # else: _info_obj = None done in clone_reader_document_root()
+
+ try:
+ self._ID = cast(ArrayObject, reader._ID).clone(self)
+ except AttributeError:
+ pass
+
+ if callable(after_page_append):
+ for page in cast(
+ ArrayObject, cast(DictionaryObject, self._pages.get_object())["/Kids"]
+ ):
+ after_page_append(page.get_object())
+
+ def _compute_document_identifier(self) -> ByteStringObject:
+ stream = BytesIO()
+ self._write_pdf_structure(stream)
+ stream.seek(0)
+ return ByteStringObject(_rolling_checksum(stream).encode("utf8"))
+
+ def generate_file_identifiers(self) -> None:
+ """
+ Generate an identifier for the PDF that will be written.
+
+ The only point of this is ensuring uniqueness. Reproducibility is not
+ required.
+ When a file is first written, both identifiers shall be set to the same value.
+ If both identifiers match when a file reference is resolved, it is very
+ likely that the correct and unchanged file has been found. If only the first
+ identifier matches, a different version of the correct file has been found.
+ see §14.4 "File Identifiers".
+ """
+ if self._ID:
+ id1 = self._ID[0]
+ id2 = self._compute_document_identifier()
+ else:
+ id1 = self._compute_document_identifier()
+ id2 = id1
+ self._ID = ArrayObject((id1, id2))
+
+ def encrypt(
+ self,
+ user_password: str,
+ owner_password: Optional[str] = None,
+ use_128bit: bool = True,
+ permissions_flag: UserAccessPermissions = ALL_DOCUMENT_PERMISSIONS,
+ *,
+ algorithm: Optional[str] = None,
+ ) -> None:
+ """
+ Encrypt this PDF file with the PDF Standard encryption handler.
+
+ Args:
+ user_password: The password which allows for opening
+ and reading the PDF file with the restrictions provided.
+ owner_password: The password which allows for
+ opening the PDF files without any restrictions. By default,
+ the owner password is the same as the user password.
+ use_128bit: flag as to whether to use 128bit
+ encryption. When false, 40bit encryption will be used.
+ By default, this flag is on.
+ permissions_flag: permissions as described in
+ Table 3.20 of the PDF 1.7 specification. A bit value of 1 means
+ the permission is granted.
+ Hence an integer value of -1 will set all flags.
+ Bit position 3 is for printing, 4 is for modifying content,
+ 5 and 6 control annotations, 9 for form fields,
+ 10 for extraction of text and graphics.
+ algorithm: encrypt algorithm. Values may be one of "RC4-40", "RC4-128",
+ "AES-128", "AES-256-R5", "AES-256". If it is valid,
+ `use_128bit` will be ignored.
+
+ """
+ if owner_password is None:
+ owner_password = user_password
+
+ if algorithm is not None:
+ try:
+ alg = getattr(EncryptAlgorithm, algorithm.replace("-", "_"))
+ except AttributeError:
+ raise ValueError(f"Algorithm '{algorithm}' NOT supported")
+ else:
+ alg = EncryptAlgorithm.RC4_128
+ if not use_128bit:
+ alg = EncryptAlgorithm.RC4_40
+ self.generate_file_identifiers()
+ assert self._ID
+ self._encryption = Encryption.make(alg, permissions_flag, self._ID[0])
+ # in case call `encrypt` again
+ entry = self._encryption.write_entry(user_password, owner_password)
+ if self._encrypt_entry:
+ # replace old encrypt_entry
+ assert self._encrypt_entry.indirect_reference is not None
+ entry.indirect_reference = self._encrypt_entry.indirect_reference
+ self._objects[entry.indirect_reference.idnum - 1] = entry
+ else:
+ self._add_object(entry)
+ self._encrypt_entry = entry
+
+ def _resolve_links(self) -> None:
+ """Patch up links that were added to the document earlier, to
+ make sure they still point to the same pages.
+ """
+ for (new_link, old_link) in self._unresolved_links:
+ old_page = old_link.find_referenced_page()
+ if not old_page:
+ continue
+ new_page = self._merged_in_pages.get(old_page)
+ if new_page is None:
+ continue
+ new_link.patch_reference(self, new_page)
+
+ def write_stream(self, stream: StreamType) -> None:
+ if hasattr(stream, "mode") and "b" not in stream.mode:
+ logger_warning(
+ f"File <{stream.name}> to write to is not in binary mode. "
+ "It may not be written to correctly.",
+ __name__,
+ )
+ self._resolve_links()
+
+ if self.incremental:
+ self._reader.stream.seek(0)
+ stream.write(self._reader.stream.read(-1))
+ if len(self.list_objects_in_increment()) > 0:
+ self._write_increment(stream) # writes objs, xref stream and startxref
+ else:
+ object_positions, free_objects = self._write_pdf_structure(stream)
+ xref_location = self._write_xref_table(
+ stream, object_positions, free_objects
+ )
+ self._write_trailer(stream, xref_location)
+
+ def write(self, stream: Union[Path, StrByteType]) -> tuple[bool, IO[Any]]:
+ """
+ Write the collection of pages added to this object out as a PDF file.
+
+ Args:
+ stream: An object to write the file to. The object can support
+ the write method and the tell method, similar to a file object, or
+ be a file path, just like the fileobj, just named it stream to keep
+ existing workflow.
+
+ Returns:
+ A tuple (bool, IO).
+
+ """
+ my_file = False
+
+ if stream == "":
+ raise ValueError(f"Output({stream=}) is empty.")
+
+ if isinstance(stream, (str, Path)):
+ stream = FileIO(stream, "wb")
+ my_file = True
+
+ self.write_stream(stream)
+
+ if my_file:
+ stream.close()
+ else:
+ stream.flush()
+
+ return my_file, stream
+
+ def list_objects_in_increment(self) -> list[IndirectObject]:
+ """
+ For analysis or debugging.
+ Provides the list of new or modified objects that will be written
+ in the increment.
+ Deleted objects will not be freed but will become orphans.
+
+ Returns:
+ List of new or modified IndirectObjects
+
+ """
+ original_hash_count = len(self._original_hash)
+ return [
+ cast(IndirectObject, obj).indirect_reference
+ for i, obj in enumerate(self._objects)
+ if (
+ obj is not None
+ and (
+ i >= original_hash_count
+ or obj.hash_bin() != self._original_hash[i]
+ )
+ )
+ ]
+
+ def _write_increment(self, stream: StreamType) -> None:
+ object_positions = {}
+ object_blocks = []
+ current_start = -1
+ current_stop = -2
+ original_hash_count = len(self._original_hash)
+ for i, obj in enumerate(self._objects):
+ if obj is not None and (
+ i >= original_hash_count
+ or obj.hash_bin() != self._original_hash[i]
+ ):
+ idnum = i + 1
+ assert isinstance(obj, PdfObject), "mypy"
+ # first write new/modified object
+ object_positions[idnum] = stream.tell()
+ stream.write(f"{idnum} 0 obj\n".encode())
+ """ encryption is not operational
+ if self._encryption and obj != self._encrypt_entry:
+ obj = self._encryption.encrypt_object(obj, idnum, 0)
+ """
+ obj.write_to_stream(stream)
+ stream.write(b"\nendobj\n")
+
+ # prepare xref
+ if idnum != current_stop:
+ if current_start > 0:
+ object_blocks.append(
+ [current_start, current_stop - current_start]
+ )
+ current_start = idnum
+ current_stop = idnum + 1
+ assert current_start > 0, "for pytest only"
+ object_blocks.append([current_start, current_stop - current_start])
+ # write incremented xref
+ xref_location = stream.tell()
+ xr_id = len(self._objects) + 1
+ stream.write(f"{xr_id} 0 obj".encode())
+ init_data = {
+ NameObject("/Type"): NameObject("/XRef"),
+ NameObject("/Size"): NumberObject(xr_id + 1),
+ NameObject("/Root"): self.root_object.indirect_reference,
+ NameObject("/Filter"): NameObject("/FlateDecode"),
+ NameObject("/Index"): ArrayObject(
+ [NumberObject(_it) for _su in object_blocks for _it in _su]
+ ),
+ NameObject("/W"): ArrayObject(
+ [NumberObject(1), NumberObject(4), NumberObject(1)]
+ ),
+ "__streamdata__": b"",
+ }
+ if self._info is not None and (
+ self._info.indirect_reference.idnum - 1 # type: ignore
+ >= len(self._original_hash)
+ or cast(IndirectObject, self._info).hash_bin() # kept for future
+ != self._original_hash[
+ self._info.indirect_reference.idnum - 1 # type: ignore
+ ]
+ ):
+ init_data[NameObject(TK.INFO)] = self._info.indirect_reference
+ init_data[NameObject(TK.PREV)] = NumberObject(self._reader._startxref)
+ if self._ID:
+ init_data[NameObject(TK.ID)] = self._ID
+ xr = StreamObject.initialize_from_dictionary(init_data)
+ xr.set_data(
+ b"".join(
+ [struct.pack(b">BIB", 1, _pos, 0) for _pos in object_positions.values()]
+ )
+ )
+ xr.write_to_stream(stream)
+ stream.write(f"\nendobj\nstartxref\n{xref_location}\n%%EOF\n".encode()) # eof
+
+ def _write_pdf_structure(self, stream: StreamType) -> tuple[list[int], list[int]]:
+ object_positions = []
+ free_objects = []
+ stream.write(self.pdf_header.encode() + b"\n")
+ stream.write(b"%\xE2\xE3\xCF\xD3\n")
+
+ for idnum, obj in enumerate(self._objects, start=1):
+ if obj is not None:
+ object_positions.append(stream.tell())
+ stream.write(f"{idnum} 0 obj\n".encode())
+ if self._encryption and obj != self._encrypt_entry:
+ obj = self._encryption.encrypt_object(obj, idnum, 0)
+ obj.write_to_stream(stream)
+ stream.write(b"\nendobj\n")
+ else:
+ object_positions.append(-1)
+ free_objects.append(idnum)
+ free_objects.append(0) # add 0 to loop in accordance with specification
+ return object_positions, free_objects
+
+ def _write_xref_table(
+ self, stream: StreamType, object_positions: list[int], free_objects: list[int]
+ ) -> int:
+ xref_location = stream.tell()
+ stream.write(b"xref\n")
+ stream.write(f"0 {len(self._objects) + 1}\n".encode())
+ stream.write(f"{free_objects[0]:0>10} {65535:0>5} f \n".encode())
+ free_idx = 1
+ for offset in object_positions:
+ if offset > 0:
+ stream.write(f"{offset:0>10} {0:0>5} n \n".encode())
+ else:
+ stream.write(f"{free_objects[free_idx]:0>10} {1:0>5} f \n".encode())
+ free_idx += 1
+ return xref_location
+
+ def _write_trailer(self, stream: StreamType, xref_location: int) -> None:
+ """
+ Write the PDF trailer to the stream.
+
+ To quote the PDF specification:
+ [The] trailer [gives] the location of the cross-reference table and
+ of certain special objects within the body of the file.
+ """
+ stream.write(b"trailer\n")
+ trailer = DictionaryObject(
+ {
+ NameObject(TK.SIZE): NumberObject(len(self._objects) + 1),
+ NameObject(TK.ROOT): self.root_object.indirect_reference,
+ }
+ )
+ if self._info is not None:
+ trailer[NameObject(TK.INFO)] = self._info.indirect_reference
+ if self._ID is not None:
+ trailer[NameObject(TK.ID)] = self._ID
+ if self._encrypt_entry:
+ trailer[NameObject(TK.ENCRYPT)] = self._encrypt_entry.indirect_reference
+ trailer.write_to_stream(stream)
+ stream.write(f"\nstartxref\n{xref_location}\n%%EOF\n".encode()) # eof
+
+ @property
+ def metadata(self) -> Optional[DocumentInformation]:
+ """
+ Retrieve/set the PDF file's document information dictionary, if it exists.
+
+ Args:
+ value: dict with the entries to be set. if None : remove the /Info entry from the pdf.
+
+ Note that some PDF files use (XMP) metadata streams instead of document
+ information dictionaries, and these metadata streams will not be
+ accessed by this function, but by :meth:`~xmp_metadata`.
+
+ """
+ return super().metadata
+
+ @metadata.setter
+ def metadata(
+ self,
+ value: Optional[Union[DocumentInformation, DictionaryObject, dict[Any, Any]]],
+ ) -> None:
+ if value is None:
+ self._info = None
+ else:
+ if self._info is not None:
+ self._info.clear()
+
+ self.add_metadata(value)
+
+ def add_metadata(self, infos: dict[str, Any]) -> None:
+ """
+ Add custom metadata to the output.
+
+ Args:
+ infos: a Python dictionary where each key is a field
+ and each value is your new metadata.
+
+ """
+ args = {}
+ if isinstance(infos, PdfObject):
+ infos = cast(DictionaryObject, infos.get_object())
+ for key, value in list(infos.items()):
+ if isinstance(value, PdfObject):
+ value = value.get_object()
+ args[NameObject(key)] = create_string_object(str(value))
+ if self._info is None:
+ self._info = DictionaryObject()
+ self._info.update(args)
+
+ def compress_identical_objects(
+ self,
+ remove_identicals: bool = True,
+ remove_orphans: bool = True,
+ ) -> None:
+ """
+ Parse the PDF file and merge objects that have the same hash.
+ This will make objects common to multiple pages.
+ Recommended to be used just before writing output.
+
+ Args:
+ remove_identicals: Remove identical objects.
+ remove_orphans: Remove unreferenced objects.
+
+ """
+
+ def replace_in_obj(
+ obj: PdfObject, crossref: dict[IndirectObject, IndirectObject]
+ ) -> None:
+ if isinstance(obj, DictionaryObject):
+ key_val = obj.items()
+ elif isinstance(obj, ArrayObject):
+ key_val = enumerate(obj) # type: ignore
+ else:
+ return
+ assert isinstance(obj, (DictionaryObject, ArrayObject))
+ for k, v in key_val:
+ if isinstance(v, IndirectObject):
+ orphans[v.idnum - 1] = False
+ if v in crossref:
+ obj[k] = crossref[v]
+ else:
+ """the filtering on DictionaryObject and ArrayObject only
+ will be performed within replace_in_obj"""
+ replace_in_obj(v, crossref)
+
+ # _idnum_hash :dict[hash]=(1st_ind_obj,[other_indir_objs,...])
+ self._idnum_hash = {}
+ orphans = [True] * len(self._objects)
+ # look for similar objects
+ for idx, obj in enumerate(self._objects):
+ if is_null_or_none(obj):
+ continue
+ assert obj is not None, "mypy" # mypy: TypeGuard of `is_null_or_none` does not help here.
+ assert isinstance(obj.indirect_reference, IndirectObject)
+ h = obj.hash_value()
+ if remove_identicals and h in self._idnum_hash:
+ self._idnum_hash[h][1].append(obj.indirect_reference)
+ self._objects[idx] = None
+ else:
+ self._idnum_hash[h] = (obj.indirect_reference, [])
+
+ # generate the dict converting others to 1st
+ cnv = {v[0]: v[1] for v in self._idnum_hash.values() if len(v[1]) > 0}
+ cnv_rev: dict[IndirectObject, IndirectObject] = {}
+ for k, v in cnv.items():
+ cnv_rev.update(zip(v, (k,) * len(v)))
+
+ # replace reference to merged objects
+ for obj in self._objects:
+ if isinstance(obj, (DictionaryObject, ArrayObject)):
+ replace_in_obj(obj, cnv_rev)
+
+ # remove orphans (if applicable)
+ orphans[self.root_object.indirect_reference.idnum - 1] = False # type: ignore
+
+ orphans[self._info.indirect_reference.idnum - 1] = False # type: ignore
+
+ try:
+ orphans[self._ID.indirect_reference.idnum - 1] = False # type: ignore
+ except AttributeError:
+ pass
+ for i in compress(range(len(self._objects)), orphans):
+ self._objects[i] = None
+
+ def get_reference(self, obj: PdfObject) -> IndirectObject:
+ idnum = self._objects.index(obj) + 1
+ ref = IndirectObject(idnum, 0, self)
+ assert ref.get_object() == obj
+ return ref
+
+ def get_outline_root(self) -> TreeObject:
+ if CO.OUTLINES in self._root_object:
+ # Entries in the catalog dictionary
+ outline = cast(TreeObject, self._root_object[CO.OUTLINES])
+ if not isinstance(outline, TreeObject):
+ t = TreeObject(outline)
+ self._replace_object(outline.indirect_reference.idnum, t)
+ outline = t
+ idnum = self._objects.index(outline) + 1
+ outline_ref = IndirectObject(idnum, 0, self)
+ assert outline_ref.get_object() == outline
+ else:
+ outline = TreeObject()
+ outline.update({})
+ outline_ref = self._add_object(outline)
+ self._root_object[NameObject(CO.OUTLINES)] = outline_ref
+
+ return outline
+
+ def get_threads_root(self) -> ArrayObject:
+ """
+ The list of threads.
+
+ See §12.4.3 of the PDF 1.7 or PDF 2.0 specification.
+
+ Returns:
+ An array (possibly empty) of Dictionaries with an ``/F`` key,
+ and optionally information about the thread in ``/I`` or ``/Metadata`` keys.
+
+ """
+ if CO.THREADS in self._root_object:
+ # Entries in the catalog dictionary
+ threads = cast(ArrayObject, self._root_object[CO.THREADS])
+ else:
+ threads = ArrayObject()
+ self._root_object[NameObject(CO.THREADS)] = threads
+ return threads
+
+ @property
+ def threads(self) -> ArrayObject:
+ """
+ Read-only property for the list of threads.
+
+ See §12.4.3 of the PDF 1.7 or PDF 2.0 specification.
+
+ Each element is a dictionary with an ``/F`` key, and optionally
+ information about the thread in ``/I`` or ``/Metadata`` keys.
+ """
+ return self.get_threads_root()
+
+ def add_outline_item_destination(
+ self,
+ page_destination: Union[IndirectObject, PageObject, TreeObject],
+ parent: Union[None, TreeObject, IndirectObject] = None,
+ before: Union[None, TreeObject, IndirectObject] = None,
+ is_open: bool = True,
+ ) -> IndirectObject:
+ page_destination = cast(PageObject, page_destination.get_object())
+ if isinstance(page_destination, PageObject):
+ return self.add_outline_item_destination(
+ Destination(
+ f"page #{page_destination.page_number}",
+ cast(IndirectObject, page_destination.indirect_reference),
+ Fit.fit(),
+ )
+ )
+
+ if parent is None:
+ parent = self.get_outline_root()
+
+ page_destination[NameObject("/%is_open%")] = BooleanObject(is_open)
+ parent = cast(TreeObject, parent.get_object())
+ page_destination_ref = self._add_object(page_destination)
+ if before is not None:
+ before = before.indirect_reference
+ parent.insert_child(
+ page_destination_ref,
+ before,
+ self,
+ page_destination.inc_parent_counter_outline
+ if is_open
+ else (lambda x, y: 0), # noqa: ARG005
+ )
+ if "/Count" not in page_destination:
+ page_destination[NameObject("/Count")] = NumberObject(0)
+
+ return page_destination_ref
+
+ def add_outline_item_dict(
+ self,
+ outline_item: OutlineItemType,
+ parent: Union[None, TreeObject, IndirectObject] = None,
+ before: Union[None, TreeObject, IndirectObject] = None,
+ is_open: bool = True,
+ ) -> IndirectObject:
+ outline_item_object = TreeObject()
+ outline_item_object.update(outline_item)
+
+ """code currently unreachable
+ if "/A" in outline_item:
+ action = DictionaryObject()
+ a_dict = cast(DictionaryObject, outline_item["/A"])
+ for k, v in list(a_dict.items()):
+ action[NameObject(str(k))] = v
+ action_ref = self._add_object(action)
+ outline_item_object[NameObject("/A")] = action_ref
+ """
+ return self.add_outline_item_destination(
+ outline_item_object, parent, before, is_open
+ )
+
+ def add_outline_item(
+ self,
+ title: str,
+ page_number: Union[None, PageObject, IndirectObject, int],
+ parent: Union[None, TreeObject, IndirectObject] = None,
+ before: Union[None, TreeObject, IndirectObject] = None,
+ color: Optional[Union[tuple[float, float, float], str]] = None,
+ bold: bool = False,
+ italic: bool = False,
+ fit: Fit = PAGE_FIT,
+ is_open: bool = True,
+ ) -> IndirectObject:
+ """
+ Add an outline item (commonly referred to as a "Bookmark") to the PDF file.
+
+ Args:
+ title: Title to use for this outline item.
+ page_number: Page number this outline item will point to.
+ parent: A reference to a parent outline item to create nested
+ outline items.
+ before:
+ color: Color of the outline item's font as a red, green, blue tuple
+ from 0.0 to 1.0 or as a Hex String (#RRGGBB)
+ bold: Outline item font is bold
+ italic: Outline item font is italic
+ fit: The fit of the destination page.
+
+ Returns:
+ The added outline item as an indirect object.
+
+ """
+ page_ref: Union[None, NullObject, IndirectObject, NumberObject]
+ if isinstance(italic, Fit): # it means that we are on the old params
+ if fit is not None and page_number is None:
+ page_number = fit
+ return self.add_outline_item(
+ title, page_number, parent, None, before, color, bold, italic, is_open=is_open
+ )
+ if page_number is None:
+ action_ref = None
+ else:
+ if isinstance(page_number, IndirectObject):
+ page_ref = page_number
+ elif isinstance(page_number, PageObject):
+ page_ref = page_number.indirect_reference
+ elif isinstance(page_number, int):
+ try:
+ page_ref = self.pages[page_number].indirect_reference
+ except IndexError:
+ page_ref = NumberObject(page_number)
+ if page_ref is None:
+ logger_warning(
+ f"can not find reference of page {page_number}",
+ __name__,
+ )
+ page_ref = NullObject()
+ dest = Destination(
+ NameObject("/" + title + " outline item"),
+ page_ref,
+ fit,
+ )
+
+ action_ref = self._add_object(
+ DictionaryObject(
+ {
+ NameObject(GoToActionArguments.D): dest.dest_array,
+ NameObject(GoToActionArguments.S): NameObject("/GoTo"),
+ }
+ )
+ )
+ outline_item = self._add_object(
+ _create_outline_item(action_ref, title, color, italic, bold)
+ )
+
+ if parent is None:
+ parent = self.get_outline_root()
+ return self.add_outline_item_destination(outline_item, parent, before, is_open)
+
+ def add_outline(self) -> None:
+ raise NotImplementedError(
+ "This method is not yet implemented. Use :meth:`add_outline_item` instead."
+ )
+
+ def add_named_destination_array(
+ self, title: TextStringObject, destination: Union[IndirectObject, ArrayObject]
+ ) -> None:
+ named_dest = self.get_named_dest_root()
+ i = 0
+ while i < len(named_dest):
+ if title < named_dest[i]:
+ named_dest.insert(i, destination)
+ named_dest.insert(i, TextStringObject(title))
+ return
+ i += 2
+ named_dest.extend([TextStringObject(title), destination])
+ return
+
+ def add_named_destination_object(
+ self,
+ page_destination: PdfObject,
+ ) -> IndirectObject:
+ page_destination_ref = self._add_object(page_destination.dest_array) # type: ignore
+ self.add_named_destination_array(
+ cast("TextStringObject", page_destination["/Title"]), page_destination_ref # type: ignore
+ )
+
+ return page_destination_ref
+
+ def add_named_destination(
+ self,
+ title: str,
+ page_number: int,
+ ) -> IndirectObject:
+ page_ref = self.get_object(self._pages)[PagesAttributes.KIDS][page_number] # type: ignore
+ dest = DictionaryObject()
+ dest.update(
+ {
+ NameObject(GoToActionArguments.D): ArrayObject(
+ [page_ref, NameObject(TypFitArguments.FIT_H), NumberObject(826)]
+ ),
+ NameObject(GoToActionArguments.S): NameObject("/GoTo"),
+ }
+ )
+
+ dest_ref = self._add_object(dest)
+ if not isinstance(title, TextStringObject):
+ title = TextStringObject(str(title))
+
+ self.add_named_destination_array(title, dest_ref)
+ return dest_ref
+
+ def remove_links(self) -> None:
+ """Remove links and annotations from this output."""
+ for page in self.pages:
+ self.remove_objects_from_page(page, ObjectDeletionFlag.ALL_ANNOTATIONS)
+
+ def remove_annotations(
+ self, subtypes: Optional[Union[AnnotationSubtype, Iterable[AnnotationSubtype]]]
+ ) -> None:
+ """
+ Remove annotations by annotation subtype.
+
+ Args:
+ subtypes: subtype or list of subtypes to be removed.
+ Examples are: "/Link", "/FileAttachment", "/Sound",
+ "/Movie", "/Screen", ...
+ If you want to remove all annotations, use subtypes=None.
+
+ """
+ for page in self.pages:
+ self._remove_annots_from_page(page, subtypes)
+
+ def _remove_annots_from_page(
+ self,
+ page: Union[IndirectObject, PageObject, DictionaryObject],
+ subtypes: Optional[Iterable[str]],
+ ) -> None:
+ page = cast(DictionaryObject, page.get_object())
+ if PG.ANNOTS in page:
+ i = 0
+ while i < len(cast(ArrayObject, page[PG.ANNOTS])):
+ an = cast(ArrayObject, page[PG.ANNOTS])[i]
+ obj = cast(DictionaryObject, an.get_object())
+ if subtypes is None or cast(str, obj["/Subtype"]) in subtypes:
+ if isinstance(an, IndirectObject):
+ self._objects[an.idnum - 1] = NullObject() # to reduce PDF size
+ del page[PG.ANNOTS][i] # type:ignore
+ else:
+ i += 1
+
+ def remove_objects_from_page(
+ self,
+ page: Union[PageObject, DictionaryObject],
+ to_delete: Union[ObjectDeletionFlag, Iterable[ObjectDeletionFlag]],
+ text_filters: Optional[dict[str, Any]] = None
+ ) -> None:
+ """
+ Remove objects specified by ``to_delete`` from the given page.
+
+ Args:
+ page: Page object to clean up.
+ to_delete: Objects to be deleted; can be a ``ObjectDeletionFlag``
+ or a list of ObjectDeletionFlag
+ text_filters: Properties of text to be deleted, if applicable. Optional.
+ This is a Python dictionary with the following properties:
+
+ * font_ids: List of font resource IDs (such as /F1 or /T1_0) to be deleted.
+
+ """
+ if isinstance(to_delete, (list, tuple)):
+ for to_d in to_delete:
+ self.remove_objects_from_page(page, to_d)
+ return None
+ assert isinstance(to_delete, ObjectDeletionFlag)
+
+ if to_delete & ObjectDeletionFlag.LINKS:
+ return self._remove_annots_from_page(page, ("/Link",))
+ if to_delete & ObjectDeletionFlag.ATTACHMENTS:
+ return self._remove_annots_from_page(
+ page, ("/FileAttachment", "/Sound", "/Movie", "/Screen")
+ )
+ if to_delete & ObjectDeletionFlag.OBJECTS_3D:
+ return self._remove_annots_from_page(page, ("/3D",))
+ if to_delete & ObjectDeletionFlag.ALL_ANNOTATIONS:
+ return self._remove_annots_from_page(page, None)
+
+ jump_operators = []
+ if to_delete & ObjectDeletionFlag.DRAWING_IMAGES:
+ jump_operators = (
+ [
+ b"w", b"J", b"j", b"M", b"d", b"i",
+ b"W", b"W*",
+ b"b", b"b*", b"B", b"B*", b"S", b"s", b"f", b"f*", b"F", b"n",
+ b"m", b"l", b"c", b"v", b"y", b"h", b"re",
+ b"sh"
+ ]
+ )
+ if to_delete & ObjectDeletionFlag.TEXT:
+ jump_operators = [b"Tj", b"TJ", b"'", b'"']
+
+ def clean(
+ content: ContentStream,
+ images: list[str],
+ forms: list[str],
+ text_filters: Optional[dict[str, Any]] = None
+ ) -> None:
+ nonlocal jump_operators, to_delete
+
+ font_id = None
+ font_ids_to_delete = []
+ if text_filters and to_delete & ObjectDeletionFlag.TEXT:
+ font_ids_to_delete = text_filters.get("font_ids", [])
+
+ i = 0
+ while i < len(content.operations):
+ operands, operator = content.operations[i]
+ if operator == b"Tf":
+ font_id = operands[0]
+ if (
+ (
+ operator == b"INLINE IMAGE"
+ and (to_delete & ObjectDeletionFlag.INLINE_IMAGES)
+ )
+ or (operator in jump_operators)
+ or (
+ operator == b"Do"
+ and (to_delete & ObjectDeletionFlag.XOBJECT_IMAGES)
+ and (operands[0] in images)
+ )
+ ):
+ if (
+ not to_delete & ObjectDeletionFlag.TEXT
+ or (to_delete & ObjectDeletionFlag.TEXT and not text_filters)
+ or (to_delete & ObjectDeletionFlag.TEXT and font_id in font_ids_to_delete)
+ ):
+ del content.operations[i]
+ else:
+ i += 1
+ else:
+ i += 1
+ content.get_data() # this ensures ._data is rebuilt from the .operations
+
+ def clean_forms(
+ elt: DictionaryObject, stack: list[DictionaryObject]
+ ) -> tuple[list[str], list[str]]:
+ nonlocal to_delete
+ # elt in recursive call is a new ContentStream object, so we have to check the indirect_reference
+ if (elt in stack) or (
+ hasattr(elt, "indirect_reference")
+ and any(
+ elt.indirect_reference == getattr(x, "indirect_reference", -1)
+ for x in stack
+ )
+ ):
+ # to prevent infinite looping
+ return [], [] # pragma: no cover
+ try:
+ d = cast(
+ dict[Any, Any],
+ cast(DictionaryObject, elt["/Resources"])["/XObject"],
+ )
+ except KeyError:
+ d = {}
+ images = []
+ forms = []
+ for k, v in d.items():
+ o = v.get_object()
+ try:
+ content: Any = None
+ if (
+ to_delete & ObjectDeletionFlag.XOBJECT_IMAGES
+ and o["/Subtype"] == "/Image"
+ ):
+ content = NullObject() # to delete the image keeping the entry
+ images.append(k)
+ if o["/Subtype"] == "/Form":
+ forms.append(k)
+ if isinstance(o, ContentStream):
+ content = o
+ else:
+ content = ContentStream(o, self)
+ content.update(
+ {
+ k1: v1
+ for k1, v1 in o.items()
+ if k1 not in ["/Length", "/Filter", "/DecodeParms"]
+ }
+ )
+ try:
+ content.indirect_reference = o.indirect_reference
+ except AttributeError: # pragma: no cover
+ pass
+ stack.append(elt)
+ clean_forms(content, stack) # clean subforms
+ if content is not None:
+ if isinstance(v, IndirectObject):
+ self._objects[v.idnum - 1] = content
+ else:
+ # should only occur in a PDF not respecting PDF spec
+ # where streams must be indirected.
+ d[k] = self._add_object(content) # pragma: no cover
+ except (TypeError, KeyError):
+ pass
+ for im in images:
+ del d[im] # for clean-up
+ if isinstance(elt, StreamObject): # for /Form
+ if not isinstance(elt, ContentStream): # pragma: no cover
+ e = ContentStream(elt, self)
+ e.update(elt.items())
+ elt = e
+ clean(elt, images, forms, text_filters) # clean the content
+ return images, forms
+
+ if not isinstance(page, PageObject):
+ page = PageObject(self, page.indirect_reference) # pragma: no cover
+ if "/Contents" in page:
+ content = cast(ContentStream, page.get_contents())
+
+ images, forms = clean_forms(page, [])
+
+ clean(content, images, forms, text_filters)
+ page.replace_contents(content)
+ return [], [] # type: ignore[return-value]
+
+ def remove_images(
+ self,
+ to_delete: ImageType = ImageType.ALL,
+ ) -> None:
+ """
+ Remove images from this output.
+
+ Args:
+ to_delete: The type of images to be deleted
+ (default = all images types)
+
+ """
+ if isinstance(to_delete, bool):
+ to_delete = ImageType.ALL
+
+ i = ObjectDeletionFlag.NONE
+
+ for image in ("XOBJECT_IMAGES", "INLINE_IMAGES", "DRAWING_IMAGES"):
+ if to_delete & ImageType[image]:
+ i |= ObjectDeletionFlag[image]
+
+ for page in self.pages:
+ self.remove_objects_from_page(page, i)
+
+ def remove_text(self, font_names: Optional[list[str]] = None) -> None:
+ """
+ Remove text from the PDF.
+
+ Args:
+ font_names: List of font names to remove, such as "Helvetica-Bold".
+ Optional. If not specified, all text will be removed.
+ """
+ if not font_names:
+ font_names = []
+
+ for page in self.pages:
+ resource_ids_to_remove = []
+
+ # Content streams reference fonts and other resources with names like "/F1" or "/T1_0"
+ # Font names need to be converted to resource names/IDs for easier removal
+ if font_names:
+ # Recursively loop through page objects to gather font info
+ def get_font_info(
+ obj: Any,
+ font_info: Optional[dict[str, Any]] = None,
+ key: Optional[str] = None
+ ) -> dict[str, Any]:
+ if font_info is None:
+ font_info = {}
+ if isinstance(obj, IndirectObject):
+ obj = obj.get_object()
+ if isinstance(obj, dict):
+ if obj.get("/Type") == "/Font":
+ font_name = obj.get("/BaseFont", "")
+ # Normalize font names like "/RRXFFV+Palatino-Bold" to "Palatino-Bold"
+ normalized_font_name = font_name.lstrip("/").split("+")[-1]
+ if normalized_font_name not in font_info:
+ font_info[normalized_font_name] = {
+ "normalized_font_name": normalized_font_name,
+ "resource_ids": [],
+ }
+ if key not in font_info[normalized_font_name]["resource_ids"]:
+ font_info[normalized_font_name]["resource_ids"].append(key)
+ for k in obj:
+ font_info = get_font_info(obj[k], font_info, k)
+ elif isinstance(obj, (list, ArrayObject)):
+ for child_obj in obj:
+ font_info = get_font_info(child_obj, font_info)
+ return font_info
+
+ # Add relevant resource names for removal
+ font_info = get_font_info(page.get("/Resources"))
+ for font_name in font_names:
+ if font_name in font_info:
+ resource_ids_to_remove.extend(font_info[font_name]["resource_ids"])
+
+ text_filters = {}
+ if font_names:
+ text_filters["font_ids"] = resource_ids_to_remove
+ self.remove_objects_from_page(page, ObjectDeletionFlag.TEXT, text_filters=text_filters)
+
+ def add_uri(
+ self,
+ page_number: int,
+ uri: str,
+ rect: RectangleObject,
+ border: Optional[ArrayObject] = None,
+ ) -> None:
+ """
+ Add an URI from a rectangular area to the specified page.
+
+ Args:
+ page_number: index of the page on which to place the URI action.
+ uri: URI of resource to link to.
+ rect: :class:`RectangleObject` or
+ array of four integers specifying the clickable rectangular area
+ ``[xLL, yLL, xUR, yUR]``, or string in the form
+ ``"[ xLL yLL xUR yUR ]"``.
+ border: if provided, an array describing border-drawing
+ properties. See the PDF spec for details. No border will be
+ drawn if this argument is omitted.
+
+ """
+ page_link = self.get_object(self._pages)[PagesAttributes.KIDS][page_number] # type: ignore
+ page_ref = cast(dict[str, Any], self.get_object(page_link))
+
+ border_arr: BorderArrayType
+ if border is not None:
+ border_arr = [NumberObject(n) for n in border[:3]]
+ if len(border) == 4:
+ dash_pattern = ArrayObject([NumberObject(n) for n in border[3]])
+ border_arr.append(dash_pattern)
+ else:
+ border_arr = [NumberObject(2), NumberObject(2), NumberObject(2)]
+
+ if isinstance(rect, str):
+ rect = NumberObject(rect)
+ elif isinstance(rect, RectangleObject):
+ pass
+ else:
+ rect = RectangleObject(rect)
+
+ lnk2 = DictionaryObject()
+ lnk2.update(
+ {
+ NameObject("/S"): NameObject("/URI"),
+ NameObject("/URI"): TextStringObject(uri),
+ }
+ )
+ lnk = DictionaryObject()
+ lnk.update(
+ {
+ NameObject(AA.Type): NameObject("/Annot"),
+ NameObject(AA.Subtype): NameObject("/Link"),
+ NameObject(AA.P): page_link,
+ NameObject(AA.Rect): rect,
+ NameObject("/H"): NameObject("/I"),
+ NameObject(AA.Border): ArrayObject(border_arr),
+ NameObject("/A"): lnk2,
+ }
+ )
+ lnk_ref = self._add_object(lnk)
+
+ if PG.ANNOTS in page_ref:
+ page_ref[PG.ANNOTS].append(lnk_ref)
+ else:
+ page_ref[NameObject(PG.ANNOTS)] = ArrayObject([lnk_ref])
+
+ _valid_layouts = (
+ "/NoLayout",
+ "/SinglePage",
+ "/OneColumn",
+ "/TwoColumnLeft",
+ "/TwoColumnRight",
+ "/TwoPageLeft",
+ "/TwoPageRight",
+ )
+
+ def _get_page_layout(self) -> Optional[LayoutType]:
+ try:
+ return cast(LayoutType, self._root_object["/PageLayout"])
+ except KeyError:
+ return None
+
+ def _set_page_layout(self, layout: Union[NameObject, LayoutType]) -> None:
+ """
+ Set the page layout.
+
+ Args:
+ layout: The page layout to be used.
+
+ .. list-table:: Valid ``layout`` arguments
+ :widths: 50 200
+
+ * - /NoLayout
+ - Layout explicitly not specified
+ * - /SinglePage
+ - Show one page at a time
+ * - /OneColumn
+ - Show one column at a time
+ * - /TwoColumnLeft
+ - Show pages in two columns, odd-numbered pages on the left
+ * - /TwoColumnRight
+ - Show pages in two columns, odd-numbered pages on the right
+ * - /TwoPageLeft
+ - Show two pages at a time, odd-numbered pages on the left
+ * - /TwoPageRight
+ - Show two pages at a time, odd-numbered pages on the right
+
+ """
+ if not isinstance(layout, NameObject):
+ if layout not in self._valid_layouts:
+ logger_warning(
+ f"Layout should be one of: {'', ''.join(self._valid_layouts)}",
+ __name__,
+ )
+ layout = NameObject(layout)
+ self._root_object.update({NameObject("/PageLayout"): layout})
+
+ def set_page_layout(self, layout: LayoutType) -> None:
+ """
+ Set the page layout.
+
+ Args:
+ layout: The page layout to be used
+
+ .. list-table:: Valid ``layout`` arguments
+ :widths: 50 200
+
+ * - /NoLayout
+ - Layout explicitly not specified
+ * - /SinglePage
+ - Show one page at a time
+ * - /OneColumn
+ - Show one column at a time
+ * - /TwoColumnLeft
+ - Show pages in two columns, odd-numbered pages on the left
+ * - /TwoColumnRight
+ - Show pages in two columns, odd-numbered pages on the right
+ * - /TwoPageLeft
+ - Show two pages at a time, odd-numbered pages on the left
+ * - /TwoPageRight
+ - Show two pages at a time, odd-numbered pages on the right
+
+ """
+ self._set_page_layout(layout)
+
+ @property
+ def page_layout(self) -> Optional[LayoutType]:
+ """
+ Page layout property.
+
+ .. list-table:: Valid ``layout`` values
+ :widths: 50 200
+
+ * - /NoLayout
+ - Layout explicitly not specified
+ * - /SinglePage
+ - Show one page at a time
+ * - /OneColumn
+ - Show one column at a time
+ * - /TwoColumnLeft
+ - Show pages in two columns, odd-numbered pages on the left
+ * - /TwoColumnRight
+ - Show pages in two columns, odd-numbered pages on the right
+ * - /TwoPageLeft
+ - Show two pages at a time, odd-numbered pages on the left
+ * - /TwoPageRight
+ - Show two pages at a time, odd-numbered pages on the right
+ """
+ return self._get_page_layout()
+
+ @page_layout.setter
+ def page_layout(self, layout: LayoutType) -> None:
+ self._set_page_layout(layout)
+
+ _valid_modes = (
+ "/UseNone",
+ "/UseOutlines",
+ "/UseThumbs",
+ "/FullScreen",
+ "/UseOC",
+ "/UseAttachments",
+ )
+
+ def _get_page_mode(self) -> Optional[PagemodeType]:
+ try:
+ return cast(PagemodeType, self._root_object["/PageMode"])
+ except KeyError:
+ return None
+
+ @property
+ def page_mode(self) -> Optional[PagemodeType]:
+ """
+ Page mode property.
+
+ .. list-table:: Valid ``mode`` values
+ :widths: 50 200
+
+ * - /UseNone
+ - Do not show outline or thumbnails panels
+ * - /UseOutlines
+ - Show outline (aka bookmarks) panel
+ * - /UseThumbs
+ - Show page thumbnails panel
+ * - /FullScreen
+ - Fullscreen view
+ * - /UseOC
+ - Show Optional Content Group (OCG) panel
+ * - /UseAttachments
+ - Show attachments panel
+ """
+ return self._get_page_mode()
+
+ @page_mode.setter
+ def page_mode(self, mode: PagemodeType) -> None:
+ if isinstance(mode, NameObject):
+ mode_name: NameObject = mode
+ else:
+ if mode not in self._valid_modes:
+ logger_warning(
+ f"Mode should be one of: {', '.join(self._valid_modes)}", __name__
+ )
+ mode_name = NameObject(mode)
+ self._root_object.update({NameObject("/PageMode"): mode_name})
+
+ def add_annotation(
+ self,
+ page_number: Union[int, PageObject],
+ annotation: dict[str, Any],
+ ) -> DictionaryObject:
+ """
+ Add a single annotation to the page.
+ The added annotation must be a new annotation.
+ It cannot be recycled.
+
+ Args:
+ page_number: PageObject or page index.
+ annotation: Annotation to be added (created with annotation).
+
+ Returns:
+ The inserted object.
+ This can be used for popup creation, for example.
+
+ """
+ page = page_number
+ if isinstance(page, int):
+ page = self.pages[page]
+ elif not isinstance(page, PageObject):
+ raise TypeError("page: invalid type")
+
+ to_add = cast(DictionaryObject, _pdf_objectify(annotation))
+ to_add[NameObject("/P")] = page.indirect_reference
+
+ if page.annotations is None:
+ page[NameObject("/Annots")] = ArrayObject()
+ assert page.annotations is not None
+
+ # Internal link annotations need the correct object type for the
+ # destination
+ if to_add.get("/Subtype") == "/Link" and "/Dest" in to_add:
+ tmp = cast(dict[Any, Any], to_add[NameObject("/Dest")])
+ dest = Destination(
+ NameObject("/LinkName"),
+ tmp["target_page_index"],
+ Fit(
+ fit_type=tmp["fit"], fit_args=dict(tmp)["fit_args"]
+ ), # I have no clue why this dict-hack is necessary
+ )
+ to_add[NameObject("/Dest")] = dest.dest_array
+
+ page.annotations.append(self._add_object(to_add))
+
+ if to_add.get("/Subtype") == "/Popup" and NameObject("/Parent") in to_add:
+ cast(DictionaryObject, to_add["/Parent"].get_object())[
+ NameObject("/Popup")
+ ] = to_add.indirect_reference
+
+ return to_add
+
+ def clean_page(self, page: Union[PageObject, IndirectObject]) -> PageObject:
+ """
+ Perform some clean up in the page.
+ Currently: convert NameObject named destination to TextStringObject
+ (required for names/dests list)
+
+ Args:
+ page:
+
+ Returns:
+ The cleaned PageObject
+
+ """
+ page = cast("PageObject", page.get_object())
+ for a in page.get("/Annots", []):
+ a_obj = a.get_object()
+ d = a_obj.get("/Dest", None)
+ act = a_obj.get("/A", None)
+ if isinstance(d, NameObject):
+ a_obj[NameObject("/Dest")] = TextStringObject(d)
+ elif act is not None:
+ act = act.get_object()
+ d = act.get("/D", None)
+ if isinstance(d, NameObject):
+ act[NameObject("/D")] = TextStringObject(d)
+ return page
+
+ def _create_stream(
+ self, fileobj: Union[Path, StrByteType, PdfReader]
+ ) -> tuple[IOBase, Optional[Encryption]]:
+ # If the fileobj parameter is a string, assume it is a path
+ # and create a file object at that location. If it is a file,
+ # copy the file's contents into a BytesIO stream object; if
+ # it is a PdfReader, copy that reader's stream into a
+ # BytesIO stream.
+ # If fileobj is none of the above types, it is not modified
+ encryption_obj = None
+ stream: IOBase
+ if isinstance(fileobj, (str, Path)):
+ with FileIO(fileobj, "rb") as f:
+ stream = BytesIO(f.read())
+ elif isinstance(fileobj, PdfReader):
+ if fileobj._encryption:
+ encryption_obj = fileobj._encryption
+ orig_tell = fileobj.stream.tell()
+ fileobj.stream.seek(0)
+ stream = BytesIO(fileobj.stream.read())
+
+ # reset the stream to its original location
+ fileobj.stream.seek(orig_tell)
+ elif hasattr(fileobj, "seek") and hasattr(fileobj, "read"):
+ fileobj.seek(0)
+ filecontent = fileobj.read()
+ stream = BytesIO(filecontent)
+ else:
+ raise NotImplementedError(
+ "Merging requires an object that PdfReader can parse. "
+ "Typically, that is a Path or a string representing a Path, "
+ "a file object, or an object implementing .seek and .read. "
+ "Passing a PdfReader directly works as well."
+ )
+ return stream, encryption_obj
+
+ def append(
+ self,
+ fileobj: Union[StrByteType, PdfReader, Path],
+ outline_item: Union[
+ str, None, PageRange, tuple[int, int], tuple[int, int, int], list[int]
+ ] = None,
+ pages: Union[
+ None,
+ PageRange,
+ tuple[int, int],
+ tuple[int, int, int],
+ list[int],
+ list[PageObject],
+ ] = None,
+ import_outline: bool = True,
+ excluded_fields: Optional[Union[list[str], tuple[str, ...]]] = None,
+ ) -> None:
+ """
+ Identical to the :meth:`merge()` method, but assumes you want to
+ concatenate all pages onto the end of the file instead of specifying a
+ position.
+
+ Args:
+ fileobj: A File Object or an object that supports the standard
+ read and seek methods similar to a File Object. Could also be a
+ string representing a path to a PDF file.
+ outline_item: Optionally, you may specify a string to build an
+ outline (aka 'bookmark') to identify the beginning of the
+ included file.
+ pages: Can be a :class:`PageRange`
+ or a ``(start, stop[, step])`` tuple
+ or a list of pages to be processed
+ to merge only the specified range of pages from the source
+ document into the output document.
+ import_outline: You may prevent the source document's
+ outline (collection of outline items, previously referred to as
+ 'bookmarks') from being imported by specifying this as ``False``.
+ excluded_fields: Provide the list of fields/keys to be ignored
+ if ``/Annots`` is part of the list, the annotation will be ignored
+ if ``/B`` is part of the list, the articles will be ignored
+
+ """
+ if excluded_fields is None:
+ excluded_fields = ()
+ if isinstance(outline_item, (tuple, list, PageRange)):
+ if isinstance(pages, bool):
+ if not isinstance(import_outline, bool):
+ excluded_fields = import_outline
+ import_outline = pages
+ pages = outline_item
+ self.merge(
+ None,
+ fileobj,
+ None,
+ pages,
+ import_outline,
+ excluded_fields,
+ )
+ else: # if isinstance(outline_item, str):
+ self.merge(
+ None,
+ fileobj,
+ outline_item,
+ pages,
+ import_outline,
+ excluded_fields,
+ )
+
+ def merge(
+ self,
+ position: Optional[int],
+ fileobj: Union[Path, StrByteType, PdfReader],
+ outline_item: Optional[str] = None,
+ pages: Optional[Union[PageRangeSpec, list[PageObject]]] = None,
+ import_outline: bool = True,
+ excluded_fields: Optional[Union[list[str], tuple[str, ...]]] = (),
+ ) -> None:
+ """
+ Merge the pages from the given file into the output file at the
+ specified page number.
+
+ Args:
+ position: The *page number* to insert this file. File will
+ be inserted after the given number.
+ fileobj: A File Object or an object that supports the standard
+ read and seek methods similar to a File Object. Could also be a
+ string representing a path to a PDF file.
+ outline_item: Optionally, you may specify a string to build an outline
+ (aka 'bookmark') to identify the
+ beginning of the included file.
+ pages: can be a :class:`PageRange`
+ or a ``(start, stop[, step])`` tuple
+ or a list of pages to be processed
+ to merge only the specified range of pages from the source
+ document into the output document.
+ import_outline: You may prevent the source document's
+ outline (collection of outline items, previously referred to as
+ 'bookmarks') from being imported by specifying this as ``False``.
+ excluded_fields: provide the list of fields/keys to be ignored
+ if ``/Annots`` is part of the list, the annotation will be ignored
+ if ``/B`` is part of the list, the articles will be ignored
+
+ Raises:
+ TypeError: The pages attribute is not configured properly
+
+ """
+ if isinstance(fileobj, PdfDocCommon):
+ reader = fileobj
+ else:
+ stream, _encryption_obj = self._create_stream(fileobj)
+ # Create a new PdfReader instance using the stream
+ # (either file or BytesIO or StringIO) created above
+ reader = PdfReader(stream, strict=False) # type: ignore[arg-type]
+
+ if excluded_fields is None:
+ excluded_fields = ()
+ # Find the range of pages to merge.
+ if pages is None:
+ pages = list(range(len(reader.pages)))
+ elif isinstance(pages, PageRange):
+ pages = list(range(*pages.indices(len(reader.pages))))
+ elif isinstance(pages, list):
+ pass # keep unchanged
+ elif isinstance(pages, tuple) and len(pages) <= 3:
+ pages = list(range(*pages))
+ elif not isinstance(pages, tuple):
+ raise TypeError(
+ '"pages" must be a tuple of (start, stop[, step]) or a list'
+ )
+
+ srcpages = {}
+ for page in pages:
+ if isinstance(page, PageObject):
+ pg = page
+ else:
+ pg = reader.pages[page]
+ assert pg.indirect_reference is not None
+ if position is None:
+ # numbers in the exclude list identifies that the exclusion is
+ # only applicable to 1st level of cloning
+ srcpages[pg.indirect_reference.idnum] = self.add_page(
+ pg, [*list(excluded_fields), 1, "/B", 1, "/Annots"] # type: ignore
+ )
+ else:
+ srcpages[pg.indirect_reference.idnum] = self.insert_page(
+ pg, position, [*list(excluded_fields), 1, "/B", 1, "/Annots"] # type: ignore
+ )
+ position += 1
+ srcpages[pg.indirect_reference.idnum].original_page = pg
+
+ reader._named_destinations = (
+ reader.named_destinations
+ ) # need for the outline processing below
+
+ arr: Any
+
+ def _process_named_dests(dest: Any) -> None:
+ arr = dest.dest_array
+ if "/Names" in self._root_object and dest["/Title"] in cast(
+ list[Any],
+ cast(
+ DictionaryObject,
+ cast(DictionaryObject, self._root_object["/Names"]).get("/Dests", DictionaryObject()),
+ ).get("/Names", DictionaryObject()),
+ ):
+ # already exists: should not duplicate it
+ pass
+ elif dest["/Page"] is None or isinstance(dest["/Page"], NullObject):
+ pass
+ elif isinstance(dest["/Page"], int):
+ # the page reference is a page number normally not a PDF Reference
+ # page numbers as int are normally accepted only in external goto
+ try:
+ p = reader.pages[dest["/Page"]]
+ except IndexError:
+ return
+ assert p.indirect_reference is not None
+ try:
+ arr[NumberObject(0)] = NumberObject(
+ srcpages[p.indirect_reference.idnum].page_number
+ )
+ self.add_named_destination_array(dest["/Title"], arr)
+ except KeyError:
+ pass
+ elif dest["/Page"].indirect_reference.idnum in srcpages:
+ arr[NumberObject(0)] = srcpages[
+ dest["/Page"].indirect_reference.idnum
+ ].indirect_reference
+ self.add_named_destination_array(dest["/Title"], arr)
+
+ for dest in reader._named_destinations.values():
+ _process_named_dests(dest)
+
+ outline_item_typ: TreeObject
+ if outline_item is not None:
+ outline_item_typ = cast(
+ "TreeObject",
+ self.add_outline_item(
+ TextStringObject(outline_item),
+ next(iter(srcpages.values())).indirect_reference,
+ fit=PAGE_FIT,
+ ).get_object(),
+ )
+ else:
+ outline_item_typ = self.get_outline_root()
+
+ _ro = reader.root_object
+ if import_outline and CO.OUTLINES in _ro:
+ outline = self._get_filtered_outline(
+ _ro.get(CO.OUTLINES, None), srcpages, reader
+ )
+ self._insert_filtered_outline(
+ outline, outline_item_typ, None
+ ) # TODO: use before parameter
+
+ if "/Annots" not in excluded_fields:
+ for pag in srcpages.values():
+ lst = self._insert_filtered_annotations(
+ pag.original_page.get("/Annots", []), pag, srcpages, reader
+ )
+ if len(lst) > 0:
+ pag[NameObject("/Annots")] = lst
+ self.clean_page(pag)
+
+ if "/AcroForm" in _ro and not is_null_or_none(_ro["/AcroForm"]):
+ if "/AcroForm" not in self._root_object:
+ self._root_object[NameObject("/AcroForm")] = self._add_object(
+ cast(
+ DictionaryObject,
+ reader.root_object["/AcroForm"],
+ ).clone(self, False, ("/Fields",))
+ )
+ arr = ArrayObject()
+ else:
+ arr = cast(
+ ArrayObject,
+ cast(DictionaryObject, self._root_object["/AcroForm"])["/Fields"],
+ )
+ trslat = self._id_translated[id(reader)]
+ try:
+ for f in reader.root_object["/AcroForm"]["/Fields"]: # type: ignore
+ try:
+ ind = IndirectObject(trslat[f.idnum], 0, self)
+ if ind not in arr:
+ arr.append(ind)
+ except KeyError:
+ # for trslat[] which mean the field has not be copied
+ # through the page
+ pass
+ except KeyError: # for /Acroform or /Fields are not existing
+ arr = self._add_object(ArrayObject())
+ cast(DictionaryObject, self._root_object["/AcroForm"])[
+ NameObject("/Fields")
+ ] = arr
+
+ if "/B" not in excluded_fields:
+ self.add_filtered_articles("", srcpages, reader)
+
+ def _add_articles_thread(
+ self,
+ thread: DictionaryObject, # thread entry from the reader's array of threads
+ pages: dict[int, PageObject],
+ reader: PdfReader,
+ ) -> IndirectObject:
+ """
+ Clone the thread with only the applicable articles.
+
+ Args:
+ thread:
+ pages:
+ reader:
+
+ Returns:
+ The added thread as an indirect reference
+
+ """
+ nthread = thread.clone(
+ self, force_duplicate=True, ignore_fields=("/F",)
+ ) # use of clone to keep link between reader and writer
+ self.threads.append(nthread.indirect_reference)
+ first_article = cast("DictionaryObject", thread["/F"])
+ current_article: Optional[DictionaryObject] = first_article
+ new_article: Optional[DictionaryObject] = None
+ while current_article is not None:
+ pag = self._get_cloned_page(
+ cast("PageObject", current_article["/P"]), pages, reader
+ )
+ if pag is not None:
+ if new_article is None:
+ new_article = cast(
+ "DictionaryObject",
+ self._add_object(DictionaryObject()).get_object(),
+ )
+ new_first = new_article
+ nthread[NameObject("/F")] = new_article.indirect_reference
+ else:
+ new_article2 = cast(
+ "DictionaryObject",
+ self._add_object(
+ DictionaryObject(
+ {NameObject("/V"): new_article.indirect_reference}
+ )
+ ).get_object(),
+ )
+ new_article[NameObject("/N")] = new_article2.indirect_reference
+ new_article = new_article2
+ new_article[NameObject("/P")] = pag
+ new_article[NameObject("/T")] = nthread.indirect_reference
+ new_article[NameObject("/R")] = current_article["/R"]
+ pag_obj = cast("PageObject", pag.get_object())
+ if "/B" not in pag_obj:
+ pag_obj[NameObject("/B")] = ArrayObject()
+ cast("ArrayObject", pag_obj["/B"]).append(
+ new_article.indirect_reference
+ )
+ current_article = cast("DictionaryObject", current_article["/N"])
+ if current_article == first_article:
+ new_article[NameObject("/N")] = new_first.indirect_reference # type: ignore
+ new_first[NameObject("/V")] = new_article.indirect_reference # type: ignore
+ current_article = None
+ assert nthread.indirect_reference is not None
+ return nthread.indirect_reference
+
+ def add_filtered_articles(
+ self,
+ fltr: Union[
+ Pattern[Any], str
+ ], # thread entry from the reader's array of threads
+ pages: dict[int, PageObject],
+ reader: PdfReader,
+ ) -> None:
+ """
+ Add articles matching the defined criteria.
+
+ Args:
+ fltr:
+ pages:
+ reader:
+
+ """
+ if isinstance(fltr, str):
+ fltr = re.compile(fltr)
+ elif not isinstance(fltr, Pattern):
+ fltr = re.compile("")
+ for p in pages.values():
+ pp = p.original_page
+ for a in pp.get("/B", ()):
+ a_obj = a.get_object()
+ if is_null_or_none(a_obj):
+ continue
+ thr = a_obj.get("/T")
+ if thr is None:
+ continue
+ thr = thr.get_object()
+ if thr.indirect_reference.idnum not in self._id_translated[
+ id(reader)
+ ] and fltr.search((thr.get("/I", {})).get("/Title", "")):
+ self._add_articles_thread(thr, pages, reader)
+
+ def _get_cloned_page(
+ self,
+ page: Union[None, IndirectObject, PageObject, NullObject],
+ pages: dict[int, PageObject],
+ reader: PdfReader,
+ ) -> Optional[IndirectObject]:
+ if isinstance(page, NullObject):
+ return None
+ if isinstance(page, DictionaryObject) and page.get("/Type", "") == "/Page":
+ _i = page.indirect_reference
+ elif isinstance(page, IndirectObject):
+ _i = page
+ try:
+ return pages[_i.idnum].indirect_reference # type: ignore
+ except Exception:
+ return None
+
+ def _insert_filtered_annotations(
+ self,
+ annots: Union[IndirectObject, list[DictionaryObject], None],
+ page: PageObject,
+ pages: dict[int, PageObject],
+ reader: PdfReader,
+ ) -> list[Destination]:
+ outlist = ArrayObject()
+ if isinstance(annots, IndirectObject):
+ annots = cast("list[Any]", annots.get_object())
+ if annots is None:
+ return outlist
+ if not isinstance(annots, list):
+ logger_warning(f"Expected list of annotations, got {annots} of type {annots.__class__.__name__}.", __name__)
+ return outlist
+ for an in annots:
+ ano = cast("DictionaryObject", an.get_object())
+ if (
+ ano["/Subtype"] != "/Link"
+ or "/A" not in ano
+ or cast("DictionaryObject", ano["/A"])["/S"] != "/GoTo"
+ or "/Dest" in ano
+ ):
+ if "/Dest" not in ano:
+ outlist.append(self._add_object(ano.clone(self)))
+ else:
+ d = ano["/Dest"]
+ if isinstance(d, str):
+ # it is a named dest
+ if str(d) in self.get_named_dest_root():
+ outlist.append(ano.clone(self).indirect_reference)
+ else:
+ d = cast("ArrayObject", d)
+ p = self._get_cloned_page(d[0], pages, reader)
+ if p is not None:
+ anc = ano.clone(self, ignore_fields=("/Dest",))
+ anc[NameObject("/Dest")] = ArrayObject([p, *d[1:]])
+ outlist.append(self._add_object(anc))
+ else:
+ d = cast("DictionaryObject", ano["/A"]).get("/D", NullObject())
+ if d is None or isinstance(d, NullObject):
+ continue
+ if isinstance(d, str):
+ # it is a named dest
+ if str(d) in self.get_named_dest_root():
+ outlist.append(ano.clone(self).indirect_reference)
+ else:
+ d = cast("ArrayObject", d)
+ p = self._get_cloned_page(d[0], pages, reader)
+ if p is not None:
+ anc = ano.clone(self, ignore_fields=("/D",))
+ cast("DictionaryObject", anc["/A"])[
+ NameObject("/D")
+ ] = ArrayObject([p, *d[1:]])
+ outlist.append(self._add_object(anc))
+ return outlist
+
+ def _get_filtered_outline(
+ self,
+ node: Any,
+ pages: dict[int, PageObject],
+ reader: PdfReader,
+ ) -> list[Destination]:
+ """
+ Extract outline item entries that are part of the specified page set.
+
+ Args:
+ node:
+ pages:
+ reader:
+
+ Returns:
+ A list of destination objects.
+
+ """
+ new_outline = []
+ if node is None:
+ node = NullObject()
+ node = node.get_object()
+ if is_null_or_none(node):
+ node = DictionaryObject()
+ if node.get("/Type", "") == "/Outlines" or "/Title" not in node:
+ node = node.get("/First", None)
+ if node is not None:
+ node = node.get_object()
+ new_outline += self._get_filtered_outline(node, pages, reader)
+ else:
+ v: Union[None, IndirectObject, NullObject]
+ while node is not None:
+ node = node.get_object()
+ o = cast("Destination", reader._build_outline_item(node))
+ v = self._get_cloned_page(cast("PageObject", o["/Page"]), pages, reader)
+ if v is None:
+ v = NullObject()
+ o[NameObject("/Page")] = v
+ if "/First" in node:
+ o._filtered_children = self._get_filtered_outline(
+ node["/First"], pages, reader
+ )
+ else:
+ o._filtered_children = []
+ if (
+ not isinstance(o["/Page"], NullObject)
+ or len(o._filtered_children) > 0
+ ):
+ new_outline.append(o)
+ node = node.get("/Next", None)
+ return new_outline
+
+ def _clone_outline(self, dest: Destination) -> TreeObject:
+ n_ol = TreeObject()
+ self._add_object(n_ol)
+ n_ol[NameObject("/Title")] = TextStringObject(dest["/Title"])
+ if not isinstance(dest["/Page"], NullObject):
+ if dest.node is not None and "/A" in dest.node:
+ n_ol[NameObject("/A")] = dest.node["/A"].clone(self)
+ else:
+ n_ol[NameObject("/Dest")] = dest.dest_array
+ # TODO: /SE
+ if dest.node is not None:
+ n_ol[NameObject("/F")] = NumberObject(dest.node.get("/F", 0))
+ n_ol[NameObject("/C")] = ArrayObject(
+ dest.node.get(
+ "/C", [FloatObject(0.0), FloatObject(0.0), FloatObject(0.0)]
+ )
+ )
+ return n_ol
+
+ def _insert_filtered_outline(
+ self,
+ outlines: list[Destination],
+ parent: Union[TreeObject, IndirectObject],
+ before: Union[None, TreeObject, IndirectObject] = None,
+ ) -> None:
+ for dest in outlines:
+ # TODO: can be improved to keep A and SE entries (ignored for the moment)
+ # with np=self.add_outline_item_destination(dest,parent,before)
+ if dest.get("/Type", "") == "/Outlines" or "/Title" not in dest:
+ np = parent
+ else:
+ np = self._clone_outline(dest)
+ cast(TreeObject, parent.get_object()).insert_child(np, before, self)
+ self._insert_filtered_outline(dest._filtered_children, np, None)
+
+ def close(self) -> None:
+ """Implemented for API harmonization."""
+ return
+
+ def find_outline_item(
+ self,
+ outline_item: dict[str, Any],
+ root: Optional[OutlineType] = None,
+ ) -> Optional[list[int]]:
+ if root is None:
+ o = self.get_outline_root()
+ else:
+ o = cast("TreeObject", root)
+
+ i = 0
+ while o is not None:
+ if (
+ o.indirect_reference == outline_item
+ or o.get("/Title", None) == outline_item
+ ):
+ return [i]
+ if "/First" in o:
+ res = self.find_outline_item(
+ outline_item, cast(OutlineType, o["/First"])
+ )
+ if res:
+ return ([i] if "/Title" in o else []) + res
+ if "/Next" in o:
+ i += 1
+ o = cast(TreeObject, o["/Next"])
+ else:
+ return None
+ raise PyPdfError("This line is theoretically unreachable.") # pragma: no cover
+
+ def reset_translation(
+ self, reader: Union[None, PdfReader, IndirectObject] = None
+ ) -> None:
+ """
+ Reset the translation table between reader and the writer object.
+
+ Late cloning will create new independent objects.
+
+ Args:
+ reader: PdfReader or IndirectObject referencing a PdfReader object.
+ if set to None or omitted, all tables will be reset.
+
+ """
+ if reader is None:
+ self._id_translated = {}
+ elif isinstance(reader, PdfReader):
+ try:
+ del self._id_translated[id(reader)]
+ except Exception:
+ pass
+ elif isinstance(reader, IndirectObject):
+ try:
+ del self._id_translated[id(reader.pdf)]
+ except Exception:
+ pass
+ else:
+ raise Exception("invalid parameter {reader}")
+
+ def set_page_label(
+ self,
+ page_index_from: int,
+ page_index_to: int,
+ style: Optional[PageLabelStyle] = None,
+ prefix: Optional[str] = None,
+ start: Optional[int] = 0,
+ ) -> None:
+ """
+ Set a page label to a range of pages.
+
+ Page indexes must be given starting from 0.
+ Labels must have a style, a prefix or both.
+ If a range is not assigned any page label, a decimal label starting from 1 is applied.
+
+ Args:
+ page_index_from: page index of the beginning of the range starting from 0
+ page_index_to: page index of the beginning of the range starting from 0
+ style: The numbering style to be used for the numeric portion of each page label:
+
+ * ``/D`` Decimal Arabic numerals
+ * ``/R`` Uppercase Roman numerals
+ * ``/r`` Lowercase Roman numerals
+ * ``/A`` Uppercase letters (A to Z for the first 26 pages,
+ AA to ZZ for the next 26, and so on)
+ * ``/a`` Lowercase letters (a to z for the first 26 pages,
+ aa to zz for the next 26, and so on)
+
+ prefix: The label prefix for page labels in this range.
+ start: The value of the numeric portion for the first page label
+ in the range.
+ Subsequent pages are numbered sequentially from this value,
+ which must be greater than or equal to 1.
+ Default value: 1.
+
+ """
+ if style is None and prefix is None:
+ raise ValueError("At least one of style and prefix must be given")
+ if page_index_from < 0:
+ raise ValueError("page_index_from must be greater or equal than 0")
+ if page_index_to < page_index_from:
+ raise ValueError(
+ "page_index_to must be greater or equal than page_index_from"
+ )
+ if page_index_to >= len(self.pages):
+ raise ValueError("page_index_to exceeds number of pages")
+ if start is not None and start != 0 and start < 1:
+ raise ValueError("If given, start must be greater or equal than one")
+
+ self._set_page_label(page_index_from, page_index_to, style, prefix, start)
+
+ def _set_page_label(
+ self,
+ page_index_from: int,
+ page_index_to: int,
+ style: Optional[PageLabelStyle] = None,
+ prefix: Optional[str] = None,
+ start: Optional[int] = 0,
+ ) -> None:
+ """
+ Set a page label to a range of pages.
+
+ Page indexes must be given starting from 0.
+ Labels must have a style, a prefix or both.
+ If a range is not assigned any page label a decimal label starting from 1 is applied.
+
+ Args:
+ page_index_from: page index of the beginning of the range starting from 0
+ page_index_to: page index of the beginning of the range starting from 0
+ style: The numbering style to be used for the numeric portion of each page label:
+ /D Decimal Arabic numerals
+ /R Uppercase Roman numerals
+ /r Lowercase Roman numerals
+ /A Uppercase letters (A to Z for the first 26 pages,
+ AA to ZZ for the next 26, and so on)
+ /a Lowercase letters (a to z for the first 26 pages,
+ aa to zz for the next 26, and so on)
+ prefix: The label prefix for page labels in this range.
+ start: The value of the numeric portion for the first page label
+ in the range.
+ Subsequent pages are numbered sequentially from this value,
+ which must be greater than or equal to 1. Default value: 1.
+
+ """
+ default_page_label = DictionaryObject()
+ default_page_label[NameObject("/S")] = NameObject("/D")
+
+ new_page_label = DictionaryObject()
+ if style is not None:
+ new_page_label[NameObject("/S")] = NameObject(style)
+ if prefix is not None:
+ new_page_label[NameObject("/P")] = TextStringObject(prefix)
+ if start != 0:
+ new_page_label[NameObject("/St")] = NumberObject(start)
+
+ if NameObject(CatalogDictionary.PAGE_LABELS) not in self._root_object:
+ nums = ArrayObject()
+ nums_insert(NumberObject(0), default_page_label, nums)
+ page_labels = TreeObject()
+ page_labels[NameObject("/Nums")] = nums
+ self._root_object[NameObject(CatalogDictionary.PAGE_LABELS)] = page_labels
+
+ page_labels = cast(
+ TreeObject, self._root_object[NameObject(CatalogDictionary.PAGE_LABELS)]
+ )
+ nums = cast(ArrayObject, page_labels[NameObject("/Nums")])
+
+ nums_insert(NumberObject(page_index_from), new_page_label, nums)
+ nums_clear_range(NumberObject(page_index_from), page_index_to, nums)
+ next_label_pos, *_ = nums_next(NumberObject(page_index_from), nums)
+ if next_label_pos != page_index_to + 1 and page_index_to + 1 < len(self.pages):
+ nums_insert(NumberObject(page_index_to + 1), default_page_label, nums)
+
+ page_labels[NameObject("/Nums")] = nums
+ self._root_object[NameObject(CatalogDictionary.PAGE_LABELS)] = page_labels
+
+ def _repr_mimebundle_(
+ self,
+ include: Union[None, Iterable[str]] = None,
+ exclude: Union[None, Iterable[str]] = None,
+ ) -> dict[str, Any]:
+ """
+ Integration into Jupyter Notebooks.
+
+ This method returns a dictionary that maps a mime-type to its
+ representation.
+
+ .. seealso::
+
+ https://ipython.readthedocs.io/en/stable/config/integrating.html
+ """
+ pdf_data = BytesIO()
+ self.write(pdf_data)
+ data = {
+ "application/pdf": pdf_data,
+ }
+
+ if include is not None:
+ # Filter representations based on include list
+ data = {k: v for k, v in data.items() if k in include}
+
+ if exclude is not None:
+ # Remove representations based on exclude list
+ data = {k: v for k, v in data.items() if k not in exclude}
+
+ return data
+
+
+def _pdf_objectify(obj: Union[dict[str, Any], str, float, list[Any]]) -> PdfObject:
+ if isinstance(obj, PdfObject):
+ return obj
+ if isinstance(obj, dict):
+ to_add = DictionaryObject()
+ for key, value in obj.items():
+ to_add[NameObject(key)] = _pdf_objectify(value)
+ return to_add
+ if isinstance(obj, str):
+ if obj.startswith("/"):
+ return NameObject(obj)
+ return TextStringObject(obj)
+ if isinstance(obj, (float, int)):
+ return FloatObject(obj)
+ if isinstance(obj, list):
+ return ArrayObject(_pdf_objectify(i) for i in obj)
+ raise NotImplementedError(
+ f"{type(obj)=} could not be cast to a PdfObject"
+ )
+
+
+def _create_outline_item(
+ action_ref: Union[None, IndirectObject],
+ title: str,
+ color: Union[tuple[float, float, float], str, None],
+ italic: bool,
+ bold: bool,
+) -> TreeObject:
+ outline_item = TreeObject()
+ if action_ref is not None:
+ outline_item[NameObject("/A")] = action_ref
+ outline_item.update(
+ {
+ NameObject("/Title"): create_string_object(title),
+ }
+ )
+ if color:
+ if isinstance(color, str):
+ color = hex_to_rgb(color)
+ outline_item.update(
+ {NameObject("/C"): ArrayObject([FloatObject(c) for c in color])}
+ )
+ if italic or bold:
+ format_flag = 0
+ if italic:
+ format_flag += OutlineFontFlag.italic
+ if bold:
+ format_flag += OutlineFontFlag.bold
+ outline_item.update({NameObject("/F"): NumberObject(format_flag)})
+ return outline_item
diff --git a/venv/lib/python3.12/site-packages/pypdf/_xobj_image_helpers.py b/venv/lib/python3.12/site-packages/pypdf/_xobj_image_helpers.py
new file mode 100644
index 0000000..ba0934f
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/_xobj_image_helpers.py
@@ -0,0 +1,577 @@
+"""Functions to convert an image XObject to an image"""
+
+import sys
+from io import BytesIO
+from typing import Any, Literal, Optional, Union, cast
+
+from ._utils import check_if_whitespace_only, logger_warning
+from .constants import ColorSpaces, StreamAttributes
+from .constants import FilterTypes as FT
+from .constants import ImageAttributes as IA
+from .errors import EmptyImageDataError, PdfReadError
+from .generic import (
+ ArrayObject,
+ DecodedStreamObject,
+ EncodedStreamObject,
+ NullObject,
+ TextStringObject,
+ is_null_or_none,
+)
+
+if sys.version_info[:2] >= (3, 10):
+ from typing import TypeAlias
+else:
+ from typing_extensions import TypeAlias
+
+
+try:
+ from PIL import Image, UnidentifiedImageError
+except ImportError:
+ raise ImportError(
+ "pillow is required to do image extraction. "
+ "It can be installed via 'pip install pypdf[image]'"
+ )
+
+mode_str_type: TypeAlias = Literal[
+ "", "1", "RGB", "2bits", "4bits", "P", "L", "RGBA", "CMYK"
+]
+
+MAX_IMAGE_MODE_NESTING_DEPTH: int = 10
+
+
+def _get_image_mode(
+ color_space: Union[str, list[Any], Any],
+ color_components: int,
+ prev_mode: mode_str_type,
+ depth: int = 0,
+) -> tuple[mode_str_type, bool]:
+ """
+ Returns:
+ Image mode, not taking into account mask (transparency).
+ ColorInversion is required (like for some DeviceCMYK).
+
+ """
+ if depth > MAX_IMAGE_MODE_NESTING_DEPTH:
+ raise PdfReadError(
+ "Color spaces nested too deeply. If required, consider increasing MAX_IMAGE_MODE_NESTING_DEPTH."
+ )
+ if is_null_or_none(color_space):
+ return "", False
+ color_space_str: str = ""
+ if isinstance(color_space, str):
+ color_space_str = color_space
+ elif not isinstance(color_space, list):
+ raise PdfReadError(
+ "Cannot interpret color space", color_space
+ ) # pragma: no cover
+ elif not color_space:
+ return "", False
+ elif color_space[0].startswith("/Cal"): # /CalRGB or /CalGray
+ color_space_str = "/Device" + color_space[0][4:]
+ elif color_space[0] == "/ICCBased":
+ icc_profile = color_space[1].get_object()
+ color_components = cast(int, icc_profile["/N"])
+ color_space_str = icc_profile.get("/Alternate", "")
+ elif color_space[0] == "/Indexed":
+ color_space_str = color_space[1].get_object()
+ mode, invert_color = _get_image_mode(
+ color_space_str, color_components, prev_mode, depth + 1
+ )
+ if mode in ("RGB", "CMYK"):
+ mode = "P"
+ return mode, invert_color
+ elif color_space[0] == "/Separation":
+ color_space_str = color_space[2].get_object()
+ mode, invert_color = _get_image_mode(
+ color_space_str, color_components, prev_mode, depth + 1
+ )
+ return mode, True
+ elif color_space[0] == "/DeviceN":
+ original_color_space = color_space
+ color_components = len(color_space[1])
+ color_space_str = color_space[2].get_object()
+ if color_space_str == "/DeviceCMYK" and color_components == 1:
+ if original_color_space[1][0] != "/Black":
+ logger_warning(
+ f"Color {original_color_space[1][0]} converted to Gray. Please share PDF with pypdf dev team",
+ __name__,
+ )
+ return "L", True
+ mode, invert_color = _get_image_mode(
+ color_space_str, color_components, prev_mode, depth + 1
+ )
+ return mode, invert_color
+
+ mode_map: dict[str, mode_str_type] = {
+ "1bit": "1", # must be zeroth position: color_components may index the values
+ "/DeviceGray": "L", # must be first position: color_components may index the values
+ "palette": "P", # must be second position: color_components may index the values
+ "/DeviceRGB": "RGB", # must be third position: color_components may index the values
+ "/DeviceCMYK": "CMYK", # must be fourth position: color_components may index the values
+ "2bit": "2bits",
+ "4bit": "4bits",
+ }
+
+ mode = (
+ mode_map.get(color_space_str)
+ or list(mode_map.values())[color_components]
+ or prev_mode
+ )
+
+ return mode, mode == "CMYK"
+
+
+def bits2byte(data: bytes, size: tuple[int, int], bits: int) -> bytes:
+ mask = (1 << bits) - 1
+ byte_buffer = bytearray(size[0] * size[1])
+ data_index = 0
+ bit = 8 - bits
+ for y in range(size[1]):
+ if bit != 8 - bits:
+ data_index += 1
+ bit = 8 - bits
+ for x in range(size[0]):
+ byte_buffer[x + y * size[0]] = (data[data_index] >> bit) & mask
+ bit -= bits
+ if bit < 0:
+ data_index += 1
+ bit = 8 - bits
+ return bytes(byte_buffer)
+
+
+def _extended_image_from_bytes(
+ mode: str, size: tuple[int, int], data: bytes
+) -> Image.Image:
+ try:
+ img = Image.frombytes(mode, size, data)
+ except ValueError as exc:
+ nb_pix = size[0] * size[1]
+ data_length = len(data)
+ if data_length == 0:
+ raise EmptyImageDataError(
+ "Data is 0 bytes, cannot process an image from empty data."
+ ) from exc
+ if data_length % nb_pix != 0:
+ raise exc
+ k = nb_pix * len(mode) / data_length
+ data = b"".join(bytes((x,) * int(k)) for x in data)
+ img = Image.frombytes(mode, size, data)
+ return img
+
+
+def __handle_flate__indexed(color_space: ArrayObject) -> tuple[Any, Any, Any, Any]:
+ count = len(color_space)
+ if count == 4:
+ color_space, base, hival, lookup = (value.get_object() for value in color_space)
+ return color_space, base, hival, lookup
+
+ # Deal with strange AutoDesk files where `base` and `hival` look like this:
+ # /DeviceRGB\x00255
+ element1 = color_space[1]
+ element1 = element1 if isinstance(element1, str) else element1.get_object()
+ if count == 3 and "\x00" in element1:
+ color_space, lookup = color_space[0].get_object(), color_space[2].get_object()
+ base, hival = element1.split("\x00")
+ hival = int(hival)
+ return color_space, base, hival, lookup
+ raise PdfReadError(f"Expected color space with 4 values, got {count}: {color_space}")
+
+
+def _handle_flate(
+ size: tuple[int, int],
+ data: bytes,
+ mode: mode_str_type,
+ color_space: str,
+ colors: int,
+ obj_as_text: str,
+) -> tuple[Image.Image, str, str, bool]:
+ """
+ Process image encoded in flateEncode
+ Returns img, image_format, extension, color inversion
+ """
+ extension = ".png" # mime_type: "image/png"
+ image_format = "PNG"
+ lookup: Any
+ base: Any
+ hival: Any
+ if isinstance(color_space, ArrayObject) and color_space[0] == "/Indexed":
+ color_space, base, hival, lookup = __handle_flate__indexed(color_space)
+ if mode == "2bits":
+ mode = "P"
+ data = bits2byte(data, size, 2)
+ elif mode == "4bits":
+ mode = "P"
+ data = bits2byte(data, size, 4)
+ img = _extended_image_from_bytes(mode, size, data)
+ if color_space == "/Indexed":
+ if isinstance(lookup, (EncodedStreamObject, DecodedStreamObject)):
+ lookup = lookup.get_data()
+ if isinstance(lookup, TextStringObject):
+ lookup = lookup.original_bytes
+ if isinstance(lookup, str):
+ lookup = lookup.encode()
+ try:
+ nb, conv, mode = { # type: ignore
+ "1": (0, "", ""),
+ "L": (1, "P", "L"),
+ "P": (0, "", ""),
+ "RGB": (3, "P", "RGB"),
+ "CMYK": (4, "P", "CMYK"),
+ }[_get_image_mode(base, 0, "")[0]]
+ except KeyError: # pragma: no cover
+ logger_warning(
+ f"Base {base} not coded please share the pdf file with pypdf dev team",
+ __name__,
+ )
+ lookup = None
+ else:
+ if img.mode == "1":
+ # Two values ("high" and "low").
+ expected_count = 2 * nb
+ actual_count = len(lookup)
+ if actual_count != expected_count:
+ if actual_count < expected_count:
+ logger_warning(
+ f"Not enough lookup values: Expected {expected_count}, got {actual_count}.",
+ __name__
+ )
+ lookup += bytes([0] * (expected_count - actual_count))
+ elif not check_if_whitespace_only(lookup[expected_count:]):
+ logger_warning(
+ f"Too many lookup values: Expected {expected_count}, got {actual_count}.",
+ __name__
+ )
+ lookup = lookup[:expected_count]
+ colors_arr = [lookup[:nb], lookup[nb:]]
+ arr = b"".join(
+ b"".join(
+ colors_arr[1 if img.getpixel((x, y)) > 127 else 0] # type: ignore[operator,unused-ignore] # TODO: Remove unused-ignore on Python 3.10
+ for x in range(img.size[0])
+ )
+ for y in range(img.size[1])
+ )
+ img = Image.frombytes(mode, img.size, arr)
+ else:
+ img = img.convert(conv)
+ if len(lookup) != (hival + 1) * nb:
+ logger_warning(f"Invalid Lookup Table in {obj_as_text}", __name__)
+ lookup = None
+ elif mode == "L":
+ # gray lookup does not work: it is converted to a similar RGB lookup
+ lookup = b"".join([bytes([b, b, b]) for b in lookup])
+ mode = "RGB"
+ # TODO: https://github.com/py-pdf/pypdf/pull/2039
+ # this is a work around until PIL is able to process CMYK images
+ elif mode == "CMYK":
+ _rgb = []
+ for _c, _m, _y, _k in (
+ lookup[n : n + 4] for n in range(0, 4 * (len(lookup) // 4), 4)
+ ):
+ _r = int(255 * (1 - _c / 255) * (1 - _k / 255))
+ _g = int(255 * (1 - _m / 255) * (1 - _k / 255))
+ _b = int(255 * (1 - _y / 255) * (1 - _k / 255))
+ _rgb.append(bytes((_r, _g, _b)))
+ lookup = b"".join(_rgb)
+ mode = "RGB"
+ if lookup is not None:
+ img.putpalette(lookup, rawmode=mode)
+ img = img.convert("L" if base == ColorSpaces.DEVICE_GRAY else "RGB")
+ elif not isinstance(color_space, NullObject) and color_space[0] == "/ICCBased":
+ # Table 65 - Additional Entries Specific to an ICC Profile Stream Dictionary
+ mode2 = _get_image_mode(color_space, colors, mode)[0]
+ if mode != mode2:
+ img = Image.frombytes(mode2, size, data) # reloaded as mode may have changed
+ if mode == "CMYK":
+ extension = ".tif"
+ image_format = "TIFF"
+ return img, image_format, extension, False
+
+
+def _handle_jpx(
+ size: tuple[int, int],
+ data: bytes,
+ mode: mode_str_type,
+ color_space: str,
+ colors: int,
+) -> tuple[Image.Image, str, str, bool]:
+ """
+ Process image encoded in flateEncode
+ Returns img, image_format, extension, inversion
+ """
+ extension = ".jp2" # mime_type: "image/x-jp2"
+ img1: Image.Image = Image.open(BytesIO(data), formats=("JPEG2000",))
+ mode, invert_color = _get_image_mode(color_space, colors, mode)
+ if mode == "":
+ mode = cast(mode_str_type, img1.mode)
+ invert_color = mode in ("CMYK",)
+ if img1.mode == "RGBA" and mode == "RGB":
+ mode = "RGBA"
+ # we need to convert to the good mode
+ if img1.mode == mode or {img1.mode, mode} == {"L", "P"}: # compare (unordered) sets
+ # L and P are indexed modes which should not be changed.
+ img = img1
+ elif {img1.mode, mode} == {"RGBA", "CMYK"}:
+ # RGBA / CMYK are 4bytes encoding where
+ # the encoding should be corrected
+ img = Image.frombytes(mode, img1.size, img1.tobytes())
+ else: # pragma: no cover
+ img = img1.convert(mode)
+ # CMYK conversion
+ # https://stcom/questions/38855022/conversion-from-cmyk-to-rgb-with-pillow-is-different-from-that-of-photoshop
+ # not implemented for the moment as I need to get properly the ICC
+ if img.mode == "CMYK":
+ img = img.convert("RGB")
+ image_format = "JPEG2000"
+ return img, image_format, extension, invert_color
+
+
+def _apply_decode(
+ img: Image.Image,
+ x_object_obj: dict[str, Any],
+ lfilters: FT,
+ color_space: Union[str, list[Any], Any],
+ invert_color: bool,
+) -> Image.Image:
+ # CMYK image and other color spaces without decode
+ # requires reverting scale (cf p243,2§ last sentence)
+ decode = x_object_obj.get(
+ IA.DECODE,
+ ([1.0, 0.0] * len(img.getbands()))
+ if (
+ (img.mode == "CMYK" and lfilters in (FT.DCT_DECODE, FT.JPX_DECODE))
+ or (invert_color and img.mode == "L")
+ )
+ else None,
+ )
+ if (
+ isinstance(color_space, ArrayObject)
+ and color_space[0].get_object() == "/Indexed"
+ ):
+ decode = None # decode is meaningless if Indexed
+ if (
+ isinstance(color_space, ArrayObject)
+ and color_space[0].get_object() == "/Separation"
+ ):
+ decode = [1.0, 0.0] * len(img.getbands())
+ if decode is not None and not all(decode[i] == i % 2 for i in range(len(decode))):
+ lut: list[int] = []
+ for i in range(0, len(decode), 2):
+ dmin = decode[i]
+ dmax = decode[i + 1]
+ lut.extend(
+ round(255.0 * (j / 255.0 * (dmax - dmin) + dmin)) for j in range(256)
+ )
+ img = img.point(lut)
+ return img
+
+
+def _get_mode_and_invert_color(
+ x_object_obj: dict[str, Any], colors: int, color_space: Union[str, list[Any], Any]
+) -> tuple[mode_str_type, bool]:
+ if (
+ IA.COLOR_SPACE in x_object_obj
+ and x_object_obj[IA.COLOR_SPACE] == ColorSpaces.DEVICE_RGB
+ ):
+ # https://pillow.readthedocs.io/en/stable/handbook/concepts.html#modes
+ mode: mode_str_type = "RGB"
+ if x_object_obj.get("/BitsPerComponent", 8) < 8:
+ mode, invert_color = _get_image_mode(
+ f"{x_object_obj.get('/BitsPerComponent', 8)}bit", 0, ""
+ )
+ else:
+ mode, invert_color = _get_image_mode(
+ color_space,
+ 2
+ if (
+ colors == 1
+ and (
+ not is_null_or_none(color_space)
+ and "Gray" not in color_space
+ )
+ )
+ else colors,
+ "",
+ )
+ return mode, invert_color
+
+
+def _xobj_to_image(
+ x_object: dict[str, Any],
+ pillow_parameters: Union[dict[str, Any], None] = None
+) -> tuple[Optional[str], bytes, Any]:
+ """
+ Users need to have the pillow package installed.
+
+ It's unclear if pypdf will keep this function here, hence it's private.
+ It might get removed at any point.
+
+ Args:
+ x_object:
+ pillow_parameters: parameters provided to Pillow Image.save() method,
+ cf.
+
+ Returns:
+ Tuple[file extension, bytes, PIL.Image.Image]
+
+ """
+ def _apply_alpha(
+ img: Image.Image,
+ x_object: dict[str, Any],
+ obj_as_text: str,
+ image_format: str,
+ extension: str,
+ ) -> tuple[Image.Image, str, str]:
+ alpha = None
+ if IA.S_MASK in x_object: # add alpha channel
+ alpha = _xobj_to_image(x_object[IA.S_MASK])[2]
+ if img.size != alpha.size:
+ logger_warning(
+ f"image and mask size not matching: {obj_as_text}", __name__
+ )
+ else:
+ # TODO: implement mask
+ if alpha.mode != "L":
+ alpha = alpha.convert("L")
+ if img.mode == "P":
+ img = img.convert("RGB")
+ elif img.mode == "1":
+ img = img.convert("L")
+ img.putalpha(alpha)
+ if "JPEG" in image_format:
+ image_format = "JPEG2000"
+ extension = ".jp2"
+ else:
+ image_format = "PNG"
+ extension = ".png"
+ return img, extension, image_format
+
+ # For error reporting
+ obj_as_text = (
+ x_object.indirect_reference.__repr__()
+ if x_object is None # pragma: no cover
+ else x_object.__repr__()
+ )
+
+ # Get size and data
+ size = (cast(int, x_object[IA.WIDTH]), cast(int, x_object[IA.HEIGHT]))
+ data = x_object.get_data() # type: ignore
+ if isinstance(data, str): # pragma: no cover
+ data = data.encode()
+ if len(data) % (size[0] * size[1]) == 1 and data[-1] == 0x0A: # ie. '\n'
+ data = data[:-1]
+
+ # Get color properties
+ colors = x_object.get("/Colors", 1)
+ color_space: Any = x_object.get("/ColorSpace", NullObject()).get_object()
+ if isinstance(color_space, list) and len(color_space) == 1:
+ color_space = color_space[0].get_object()
+
+ mode, invert_color = _get_mode_and_invert_color(x_object, colors, color_space)
+
+ # Get filters
+ filters = x_object.get(StreamAttributes.FILTER, NullObject()).get_object()
+ lfilters = filters[-1] if isinstance(filters, list) else filters
+ decode_parms = x_object.get(StreamAttributes.DECODE_PARMS, None)
+ if decode_parms and isinstance(decode_parms, (tuple, list)):
+ decode_parms = decode_parms[0]
+ else:
+ decode_parms = {}
+ if not isinstance(decode_parms, dict):
+ decode_parms = {}
+
+ extension = None
+ if lfilters in (FT.FLATE_DECODE, FT.RUN_LENGTH_DECODE):
+ img, image_format, extension, _ = _handle_flate(
+ size,
+ data,
+ mode,
+ color_space,
+ colors,
+ obj_as_text,
+ )
+ elif lfilters in (FT.LZW_DECODE, FT.ASCII_85_DECODE):
+ # I'm not sure if the following logic is correct.
+ # There might not be any relationship between the filters and the
+ # extension
+ if lfilters == FT.LZW_DECODE:
+ image_format = "TIFF"
+ extension = ".tiff" # mime_type = "image/tiff"
+ else:
+ image_format = "PNG"
+ extension = ".png" # mime_type = "image/png"
+ try:
+ img = Image.open(BytesIO(data), formats=("TIFF", "PNG"))
+ except UnidentifiedImageError:
+ img = _extended_image_from_bytes(mode, size, data)
+ elif lfilters == FT.DCT_DECODE:
+ img, image_format, extension = Image.open(BytesIO(data)), "JPEG", ".jpg"
+ # invert_color kept unchanged
+ elif lfilters == FT.JPX_DECODE:
+ img, image_format, extension, invert_color = _handle_jpx(
+ size, data, mode, color_space, colors
+ )
+ elif lfilters == FT.CCITT_FAX_DECODE:
+ img, image_format, extension, invert_color = (
+ Image.open(BytesIO(data), formats=("TIFF",)),
+ "TIFF",
+ ".tiff",
+ False,
+ )
+ elif lfilters == FT.JBIG2_DECODE:
+ img, image_format, extension, invert_color = (
+ Image.open(BytesIO(data), formats=("PNG", "PPM")),
+ "PNG",
+ ".png",
+ False,
+ )
+ elif mode == "CMYK":
+ img, image_format, extension, invert_color = (
+ _extended_image_from_bytes(mode, size, data),
+ "TIFF",
+ ".tif",
+ False,
+ )
+ elif mode == "":
+ raise PdfReadError(f"ColorSpace field not found in {x_object}")
+ else:
+ img, image_format, extension, invert_color = (
+ _extended_image_from_bytes(mode, size, data),
+ "PNG",
+ ".png",
+ False,
+ )
+
+ img = _apply_decode(img, x_object, lfilters, color_space, invert_color)
+ img, extension, image_format = _apply_alpha(
+ img, x_object, obj_as_text, image_format, extension
+ )
+
+ if pillow_parameters is None:
+ pillow_parameters = {}
+ # Preserve JPEG image quality - see issue #3515.
+ if image_format == "JPEG":
+ # This prevents: Cannot use 'keep' when original image is not a JPEG:
+ # "JPEG" is the value of PIL.JpegImagePlugin.JpegImageFile.format
+ img.format = "JPEG"
+ if "quality" not in pillow_parameters:
+ pillow_parameters["quality"] = "keep"
+
+ # Save image to bytes
+ img_byte_arr = BytesIO()
+ try:
+ img.save(img_byte_arr, format=image_format, **pillow_parameters)
+ except OSError: # pragma: no cover # covered with pillow 10.3
+ # in case of we convert to RGBA and then to PNG
+ img1 = img.convert("RGBA")
+ image_format = "PNG"
+ extension = ".png"
+ img_byte_arr = BytesIO()
+ img1.save(img_byte_arr, format=image_format)
+ data = img_byte_arr.getvalue()
+
+ try: # temporary try/except until other fixes of images
+ img = Image.open(BytesIO(data))
+ except Exception as exception:
+ logger_warning(f"Failed loading image: {exception}", __name__)
+ img = None # type: ignore[assignment,unused-ignore] # TODO: Remove unused-ignore on Python 3.10
+ return extension, data, img
diff --git a/venv/lib/python3.12/site-packages/pypdf/annotations/__init__.py b/venv/lib/python3.12/site-packages/pypdf/annotations/__init__.py
new file mode 100644
index 0000000..44ed1da
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/annotations/__init__.py
@@ -0,0 +1,42 @@
+"""
+PDF specifies several annotation types which pypdf makes available here.
+
+The names of the annotations and their attributes do not reflect the names in
+the specification in all cases. For example, the PDF standard defines a
+'Square' annotation that does not actually need to be square. For this reason,
+pypdf calls it 'Rectangle'.
+
+At their core, all annotation types are DictionaryObjects. That means if pypdf
+does not implement a feature, users can easily extend the given functionality.
+"""
+
+
+from ._base import NO_FLAGS, AnnotationDictionary
+from ._markup_annotations import (
+ Ellipse,
+ FreeText,
+ Highlight,
+ Line,
+ MarkupAnnotation,
+ Polygon,
+ PolyLine,
+ Rectangle,
+ Text,
+)
+from ._non_markup_annotations import Link, Popup
+
+__all__ = [
+ "NO_FLAGS",
+ "AnnotationDictionary",
+ "Ellipse",
+ "FreeText",
+ "Highlight",
+ "Line",
+ "Link",
+ "MarkupAnnotation",
+ "PolyLine",
+ "Polygon",
+ "Popup",
+ "Rectangle",
+ "Text",
+]
diff --git a/venv/lib/python3.12/site-packages/pypdf/annotations/_base.py b/venv/lib/python3.12/site-packages/pypdf/annotations/_base.py
new file mode 100644
index 0000000..dc065e1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/annotations/_base.py
@@ -0,0 +1,29 @@
+from abc import ABC
+
+from ..constants import AnnotationFlag
+from ..generic import NameObject, NumberObject
+from ..generic._data_structures import DictionaryObject
+
+
+class AnnotationDictionary(DictionaryObject, ABC):
+ def __init__(self) -> None:
+ super().__init__()
+
+ from ..generic._base import NameObject # noqa: PLC0415
+
+ # /Rect should not be added here as Polygon and PolyLine can automatically set it
+ self[NameObject("/Type")] = NameObject("/Annot")
+ # The flags were NOT added to the constructor on purpose:
+ # We expect that most users don't want to change the default.
+ # If they do, they can use the property. The default is 0.
+
+ @property
+ def flags(self) -> AnnotationFlag:
+ return self.get(NameObject("/F"), AnnotationFlag(0))
+
+ @flags.setter
+ def flags(self, value: AnnotationFlag) -> None:
+ self[NameObject("/F")] = NumberObject(value)
+
+
+NO_FLAGS = AnnotationFlag(0)
diff --git a/venv/lib/python3.12/site-packages/pypdf/annotations/_markup_annotations.py b/venv/lib/python3.12/site-packages/pypdf/annotations/_markup_annotations.py
new file mode 100644
index 0000000..6cfa387
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/annotations/_markup_annotations.py
@@ -0,0 +1,305 @@
+import sys
+from abc import ABC
+from typing import Any, Optional, Union
+
+from ..constants import AnnotationFlag
+from ..generic import ArrayObject, DictionaryObject
+from ..generic._base import (
+ BooleanObject,
+ FloatObject,
+ NameObject,
+ NumberObject,
+ TextStringObject,
+)
+from ..generic._rectangle import RectangleObject
+from ..generic._utils import hex_to_rgb
+from ._base import NO_FLAGS, AnnotationDictionary
+
+if sys.version_info[:2] >= (3, 10):
+ from typing import TypeAlias
+else:
+ # PEP 613 introduced typing.TypeAlias with Python 3.10
+ # For older Python versions, the backport typing_extensions is necessary:
+ from typing_extensions import TypeAlias
+
+
+Vertex: TypeAlias = tuple[float, float]
+
+
+def _get_bounding_rectangle(vertices: list[Vertex]) -> RectangleObject:
+ x_min, y_min = vertices[0][0], vertices[0][1]
+ x_max, y_max = vertices[0][0], vertices[0][1]
+ for x, y in vertices:
+ x_min = min(x_min, x)
+ y_min = min(y_min, y)
+ x_max = max(x_max, x)
+ y_max = max(y_max, y)
+ return RectangleObject((x_min, y_min, x_max, y_max))
+
+
+class MarkupAnnotation(AnnotationDictionary, ABC):
+ """
+ Base class for all markup annotations.
+
+ Args:
+ title_bar: Text to be displayed in the title bar of the annotation;
+ by convention this is the name of the author
+
+ """
+
+ def __init__(self, *, title_bar: Optional[str] = None) -> None:
+ if title_bar is not None:
+ self[NameObject("/T")] = TextStringObject(title_bar)
+
+
+class Text(MarkupAnnotation):
+ """
+ A text annotation.
+
+ Args:
+ rect: array of four integers ``[xLL, yLL, xUR, yUR]``
+ specifying the clickable rectangular area
+ text: The text that is added to the document
+ open:
+ flags:
+
+ """
+
+ def __init__(
+ self,
+ *,
+ rect: Union[RectangleObject, tuple[float, float, float, float]],
+ text: str,
+ open: bool = False,
+ flags: int = NO_FLAGS,
+ **kwargs: Any,
+ ) -> None:
+ super().__init__(**kwargs)
+ self[NameObject("/Subtype")] = NameObject("/Text")
+ self[NameObject("/Rect")] = RectangleObject(rect)
+ self[NameObject("/Contents")] = TextStringObject(text)
+ self[NameObject("/Open")] = BooleanObject(open)
+ self[NameObject("/Flags")] = NumberObject(flags)
+
+
+class FreeText(MarkupAnnotation):
+ """A FreeText annotation"""
+
+ def __init__(
+ self,
+ *,
+ text: str,
+ rect: Union[RectangleObject, tuple[float, float, float, float]],
+ font: str = "Helvetica",
+ bold: bool = False,
+ italic: bool = False,
+ font_size: str = "14pt",
+ font_color: str = "000000",
+ border_color: Optional[str] = "000000",
+ background_color: Optional[str] = "ffffff",
+ **kwargs: Any,
+ ) -> None:
+ super().__init__(**kwargs)
+ self[NameObject("/Subtype")] = NameObject("/FreeText")
+ self[NameObject("/Rect")] = RectangleObject(rect)
+
+ # Table 225 of the 1.7 reference ("CSS2 style attributes used in rich text strings")
+ font_str = "font: "
+ if italic:
+ font_str = f"{font_str}italic "
+ else:
+ font_str = f"{font_str}normal "
+ if bold:
+ font_str = f"{font_str}bold "
+ else:
+ font_str = f"{font_str}normal "
+ font_str = f"{font_str}{font_size} {font}"
+ font_str = f"{font_str};text-align:left;color:#{font_color}"
+
+ default_appearance_string = ""
+ if border_color:
+ for st in hex_to_rgb(border_color):
+ default_appearance_string = f"{default_appearance_string}{st} "
+ default_appearance_string = f"{default_appearance_string}rg"
+
+ self.update(
+ {
+ NameObject("/Subtype"): NameObject("/FreeText"),
+ NameObject("/Rect"): RectangleObject(rect),
+ NameObject("/Contents"): TextStringObject(text),
+ # font size color
+ NameObject("/DS"): TextStringObject(font_str),
+ NameObject("/DA"): TextStringObject(default_appearance_string),
+ }
+ )
+ if border_color is None:
+ # Border Style
+ self[NameObject("/BS")] = DictionaryObject(
+ {
+ # width of 0 means no border
+ NameObject("/W"): NumberObject(0)
+ }
+ )
+ if background_color is not None:
+ self[NameObject("/C")] = ArrayObject(
+ [FloatObject(n) for n in hex_to_rgb(background_color)]
+ )
+
+
+class Line(MarkupAnnotation):
+ def __init__(
+ self,
+ p1: Vertex,
+ p2: Vertex,
+ rect: Union[RectangleObject, tuple[float, float, float, float]],
+ text: str = "",
+ **kwargs: Any,
+ ) -> None:
+ super().__init__(**kwargs)
+ self.update(
+ {
+ NameObject("/Subtype"): NameObject("/Line"),
+ NameObject("/Rect"): RectangleObject(rect),
+ NameObject("/L"): ArrayObject(
+ [
+ FloatObject(p1[0]),
+ FloatObject(p1[1]),
+ FloatObject(p2[0]),
+ FloatObject(p2[1]),
+ ]
+ ),
+ NameObject("/LE"): ArrayObject(
+ [
+ NameObject("/None"),
+ NameObject("/None"),
+ ]
+ ),
+ NameObject("/IC"): ArrayObject(
+ [
+ FloatObject(0.5),
+ FloatObject(0.5),
+ FloatObject(0.5),
+ ]
+ ),
+ NameObject("/Contents"): TextStringObject(text),
+ }
+ )
+
+
+class PolyLine(MarkupAnnotation):
+ def __init__(
+ self,
+ vertices: list[Vertex],
+ **kwargs: Any,
+ ) -> None:
+ super().__init__(**kwargs)
+ if len(vertices) == 0:
+ raise ValueError("A polyline needs at least 1 vertex with two coordinates")
+ coord_list = []
+ for x, y in vertices:
+ coord_list.append(NumberObject(x))
+ coord_list.append(NumberObject(y))
+ self.update(
+ {
+ NameObject("/Subtype"): NameObject("/PolyLine"),
+ NameObject("/Vertices"): ArrayObject(coord_list),
+ NameObject("/Rect"): RectangleObject(_get_bounding_rectangle(vertices)),
+ }
+ )
+
+
+class Rectangle(MarkupAnnotation):
+ def __init__(
+ self,
+ rect: Union[RectangleObject, tuple[float, float, float, float]],
+ *,
+ interior_color: Optional[str] = None,
+ **kwargs: Any,
+ ) -> None:
+ super().__init__(**kwargs)
+ self.update(
+ {
+ NameObject("/Type"): NameObject("/Annot"),
+ NameObject("/Subtype"): NameObject("/Square"),
+ NameObject("/Rect"): RectangleObject(rect),
+ }
+ )
+
+ if interior_color:
+ self[NameObject("/IC")] = ArrayObject(
+ [FloatObject(n) for n in hex_to_rgb(interior_color)]
+ )
+
+
+class Highlight(MarkupAnnotation):
+ def __init__(
+ self,
+ *,
+ rect: Union[RectangleObject, tuple[float, float, float, float]],
+ quad_points: ArrayObject,
+ highlight_color: str = "ff0000",
+ printing: bool = False,
+ **kwargs: Any,
+ ) -> None:
+ super().__init__(**kwargs)
+ self.update(
+ {
+ NameObject("/Subtype"): NameObject("/Highlight"),
+ NameObject("/Rect"): RectangleObject(rect),
+ NameObject("/QuadPoints"): quad_points,
+ NameObject("/C"): ArrayObject(
+ [FloatObject(n) for n in hex_to_rgb(highlight_color)]
+ ),
+ }
+ )
+ if printing:
+ self.flags = AnnotationFlag.PRINT
+
+
+class Ellipse(MarkupAnnotation):
+ def __init__(
+ self,
+ rect: Union[RectangleObject, tuple[float, float, float, float]],
+ *,
+ interior_color: Optional[str] = None,
+ **kwargs: Any,
+ ) -> None:
+ super().__init__(**kwargs)
+
+ self.update(
+ {
+ NameObject("/Type"): NameObject("/Annot"),
+ NameObject("/Subtype"): NameObject("/Circle"),
+ NameObject("/Rect"): RectangleObject(rect),
+ }
+ )
+
+ if interior_color:
+ self[NameObject("/IC")] = ArrayObject(
+ [FloatObject(n) for n in hex_to_rgb(interior_color)]
+ )
+
+
+class Polygon(MarkupAnnotation):
+ def __init__(
+ self,
+ vertices: list[tuple[float, float]],
+ **kwargs: Any,
+ ) -> None:
+ super().__init__(**kwargs)
+ if len(vertices) == 0:
+ raise ValueError("A polygon needs at least 1 vertex with two coordinates")
+
+ coord_list = []
+ for x, y in vertices:
+ coord_list.append(NumberObject(x))
+ coord_list.append(NumberObject(y))
+ self.update(
+ {
+ NameObject("/Type"): NameObject("/Annot"),
+ NameObject("/Subtype"): NameObject("/Polygon"),
+ NameObject("/Vertices"): ArrayObject(coord_list),
+ NameObject("/IT"): NameObject("/PolygonCloud"),
+ NameObject("/Rect"): RectangleObject(_get_bounding_rectangle(vertices)),
+ }
+ )
diff --git a/venv/lib/python3.12/site-packages/pypdf/annotations/_non_markup_annotations.py b/venv/lib/python3.12/site-packages/pypdf/annotations/_non_markup_annotations.py
new file mode 100644
index 0000000..1445460
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/annotations/_non_markup_annotations.py
@@ -0,0 +1,106 @@
+from typing import TYPE_CHECKING, Any, Optional, Union
+
+from ..generic._base import (
+ BooleanObject,
+ NameObject,
+ NumberObject,
+ TextStringObject,
+)
+from ..generic._data_structures import ArrayObject, DictionaryObject
+from ..generic._fit import DEFAULT_FIT, Fit
+from ..generic._rectangle import RectangleObject
+from ._base import AnnotationDictionary
+
+
+class Link(AnnotationDictionary):
+ def __init__(
+ self,
+ *,
+ rect: Union[RectangleObject, tuple[float, float, float, float]],
+ border: Optional[ArrayObject] = None,
+ url: Optional[str] = None,
+ target_page_index: Optional[int] = None,
+ fit: Fit = DEFAULT_FIT,
+ **kwargs: Any,
+ ) -> None:
+ super().__init__(**kwargs)
+ if TYPE_CHECKING:
+ from ..types import BorderArrayType # noqa: PLC0415
+
+ is_external = url is not None
+ is_internal = target_page_index is not None
+ if not is_external and not is_internal:
+ raise ValueError(
+ "Either 'url' or 'target_page_index' have to be provided. Both were None."
+ )
+ if is_external and is_internal:
+ raise ValueError(
+ "Either 'url' or 'target_page_index' have to be provided. "
+ f"{url=}, {target_page_index=}"
+ )
+
+ border_arr: BorderArrayType
+ if border is not None:
+ border_arr = [NumberObject(n) for n in border[:3]]
+ if len(border) == 4:
+ dash_pattern = ArrayObject([NumberObject(n) for n in border[3]])
+ border_arr.append(dash_pattern)
+ else:
+ border_arr = [NumberObject(0)] * 3
+
+ self.update(
+ {
+ NameObject("/Type"): NameObject("/Annot"),
+ NameObject("/Subtype"): NameObject("/Link"),
+ NameObject("/Rect"): RectangleObject(rect),
+ NameObject("/Border"): ArrayObject(border_arr),
+ }
+ )
+ if is_external:
+ self[NameObject("/A")] = DictionaryObject(
+ {
+ NameObject("/S"): NameObject("/URI"),
+ NameObject("/Type"): NameObject("/Action"),
+ NameObject("/URI"): TextStringObject(url),
+ }
+ )
+ if is_internal:
+ # This needs to be updated later!
+ dest_deferred = DictionaryObject(
+ {
+ "target_page_index": NumberObject(target_page_index),
+ "fit": NameObject(fit.fit_type),
+ "fit_args": fit.fit_args,
+ }
+ )
+ self[NameObject("/Dest")] = dest_deferred
+
+
+class Popup(AnnotationDictionary):
+ def __init__(
+ self,
+ *,
+ rect: Union[RectangleObject, tuple[float, float, float, float]],
+ parent: Optional[DictionaryObject] = None,
+ open: bool = False,
+ **kwargs: Any,
+ ) -> None:
+ super().__init__(**kwargs)
+ self.update(
+ {
+ NameObject("/Subtype"): NameObject("/Popup"),
+ NameObject("/Rect"): RectangleObject(rect),
+ NameObject("/Open"): BooleanObject(open),
+ }
+ )
+ if parent:
+ # This needs to be an indirect object
+ try:
+ self[NameObject("/Parent")] = parent.indirect_reference
+ except AttributeError:
+ from .._utils import logger_warning # noqa: PLC0415
+
+ logger_warning(
+ "Unregistered Parent object : No Parent field set",
+ __name__,
+ )
diff --git a/venv/lib/python3.12/site-packages/pypdf/constants.py b/venv/lib/python3.12/site-packages/pypdf/constants.py
new file mode 100644
index 0000000..3f3cd9b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/constants.py
@@ -0,0 +1,796 @@
+"""Various constants, enums, and flags to aid readability."""
+
+from enum import Enum, IntFlag, auto, unique
+
+
+class StrEnum(str, Enum): # Once we are on Python 3.11+: enum.StrEnum
+ def __str__(self) -> str:
+ return str(self.value)
+
+
+class Core:
+ """Keywords that don't quite belong anywhere else."""
+
+ OUTLINES = "/Outlines"
+ THREADS = "/Threads"
+ PAGE = "/Page"
+ PAGES = "/Pages"
+ CATALOG = "/Catalog"
+
+
+class TrailerKeys:
+ SIZE = "/Size"
+ PREV = "/Prev"
+ ROOT = "/Root"
+ ENCRYPT = "/Encrypt"
+ INFO = "/Info"
+ ID = "/ID"
+
+
+class CatalogAttributes:
+ NAMES = "/Names"
+ DESTS = "/Dests"
+
+
+class EncryptionDictAttributes:
+ """
+ Additional encryption dictionary entries for the standard security handler.
+
+ Table 3.19, Page 122.
+ Table 21 of the 2.0 manual.
+ """
+
+ R = "/R" # number, required; revision of the standard security handler
+ O = "/O" # 32-byte string, required # noqa: E741
+ U = "/U" # 32-byte string, required
+ P = "/P" # integer flag, required; permitted operations
+ ENCRYPT_METADATA = "/EncryptMetadata" # boolean flag, optional
+
+
+class UserAccessPermissions(IntFlag):
+ """
+ Table 3.20 User access permissions.
+ Table 22 of the 2.0 manual.
+ """
+
+ R1 = 1
+ R2 = 2
+ PRINT = 4
+ MODIFY = 8
+ EXTRACT = 16
+ ADD_OR_MODIFY = 32
+ R7 = 64
+ R8 = 128
+ FILL_FORM_FIELDS = 256
+ EXTRACT_TEXT_AND_GRAPHICS = 512
+ ASSEMBLE_DOC = 1024
+ PRINT_TO_REPRESENTATION = 2048
+ R13 = 2**12
+ R14 = 2**13
+ R15 = 2**14
+ R16 = 2**15
+ R17 = 2**16
+ R18 = 2**17
+ R19 = 2**18
+ R20 = 2**19
+ R21 = 2**20
+ R22 = 2**21
+ R23 = 2**22
+ R24 = 2**23
+ R25 = 2**24
+ R26 = 2**25
+ R27 = 2**26
+ R28 = 2**27
+ R29 = 2**28
+ R30 = 2**29
+ R31 = 2**30
+ R32 = 2**31
+
+ @classmethod
+ def _is_reserved(cls, name: str) -> bool:
+ """Check if the given name corresponds to a reserved flag entry."""
+ return name.startswith("R") and name[1:].isdigit()
+
+ @classmethod
+ def _is_active(cls, name: str) -> bool:
+ """Check if the given reserved name defaults to 1 = active."""
+ return name not in {"R1", "R2"}
+
+ def to_dict(self) -> dict[str, bool]:
+ """Convert the given flag value to a corresponding verbose name mapping."""
+ result: dict[str, bool] = {}
+ for name, flag in UserAccessPermissions.__members__.items():
+ if UserAccessPermissions._is_reserved(name):
+ continue
+ result[name.lower()] = (self & flag) == flag
+ return result
+
+ @classmethod
+ def from_dict(cls, value: dict[str, bool]) -> "UserAccessPermissions":
+ """Convert the verbose name mapping to the corresponding flag value."""
+ value_copy = value.copy()
+ result = cls(0)
+ for name, flag in cls.__members__.items():
+ if cls._is_reserved(name):
+ # Reserved names have a required value. Use it.
+ if cls._is_active(name):
+ result |= flag
+ continue
+ is_active = value_copy.pop(name.lower(), False)
+ if is_active:
+ result |= flag
+ if value_copy:
+ raise ValueError(f"Unknown dictionary keys: {value_copy!r}")
+ return result
+
+ @classmethod
+ def all(cls) -> "UserAccessPermissions":
+ return cls((2**32 - 1) - cls.R1 - cls.R2)
+
+
+class Resources:
+ """
+ Table 3.30 Entries in a resource dictionary.
+ Table 34 in the 2.0 reference.
+ """
+
+ EXT_G_STATE = "/ExtGState" # dictionary, optional
+ COLOR_SPACE = "/ColorSpace" # dictionary, optional
+ PATTERN = "/Pattern" # dictionary, optional
+ SHADING = "/Shading" # dictionary, optional
+ XOBJECT = "/XObject" # dictionary, optional
+ FONT = "/Font" # dictionary, optional
+ PROC_SET = "/ProcSet" # array, optional
+ PROPERTIES = "/Properties" # dictionary, optional
+
+
+class PagesAttributes:
+ """§7.7.3.2 of the 1.7 and 2.0 reference."""
+
+ TYPE = "/Type" # name, required; must be /Pages
+ PARENT = "/Parent" # dictionary, required; indirect reference to pages object
+ KIDS = "/Kids" # array, required; List of indirect references
+ COUNT = "/Count"
+ # integer, required; the number of leaf nodes (page objects)
+ # that are descendants of this node within the page tree
+
+
+class PageAttributes:
+ """§7.7.3.3 of the 1.7 and 2.0 reference."""
+
+ TYPE = "/Type" # name, required; must be /Page
+ PARENT = "/Parent" # dictionary, required; a pages object
+ LAST_MODIFIED = (
+ "/LastModified" # date, optional; date and time of last modification
+ )
+ RESOURCES = "/Resources" # dictionary, required if there are any
+ MEDIABOX = "/MediaBox" # rectangle, required; rectangle specifying page size
+ CROPBOX = "/CropBox" # rectangle, optional
+ BLEEDBOX = "/BleedBox" # rectangle, optional
+ TRIMBOX = "/TrimBox" # rectangle, optional
+ ARTBOX = "/ArtBox" # rectangle, optional
+ BOX_COLOR_INFO = "/BoxColorInfo" # dictionary, optional
+ CONTENTS = "/Contents" # stream or array, optional
+ ROTATE = "/Rotate" # integer, optional; page rotation in degrees
+ GROUP = "/Group" # dictionary, optional; page group
+ THUMB = "/Thumb" # stream, optional; indirect reference to image of the page
+ B = "/B" # array, optional
+ DUR = "/Dur" # number, optional
+ TRANS = "/Trans" # dictionary, optional
+ ANNOTS = "/Annots" # array, optional; an array of annotations
+ AA = "/AA" # dictionary, optional
+ METADATA = "/Metadata" # stream, optional
+ PIECE_INFO = "/PieceInfo" # dictionary, optional
+ STRUCT_PARENTS = "/StructParents" # integer, optional
+ ID = "/ID" # byte string, optional
+ PZ = "/PZ" # number, optional
+ SEPARATION_INFO = "/SeparationInfo" # dictionary, optional
+ TABS = "/Tabs" # name, optional
+ TEMPLATE_INSTANTIATED = "/TemplateInstantiated" # name, optional
+ PRES_STEPS = "/PresSteps" # dictionary, optional
+ USER_UNIT = "/UserUnit" # number, optional
+ VP = "/VP" # dictionary, optional
+ AF = "/AF" # array of dictionaries, optional
+ OUTPUT_INTENTS = "/OutputIntents" # array, optional
+ D_PART = "/DPart" # dictionary, required, if this page is within the range of a DPart, not permitted otherwise
+
+
+class FileSpecificationDictionaryEntries:
+ """Table 3.41 Entries in a file specification dictionary."""
+
+ Type = "/Type"
+ FS = "/FS" # The name of the file system to be used to interpret this file specification
+ F = "/F" # A file specification string of the form described in §3.10.1
+ UF = "/UF" # A Unicode string of the file as described in §3.10.1
+ DOS = "/DOS"
+ Mac = "/Mac"
+ Unix = "/Unix"
+ ID = "/ID"
+ V = "/V"
+ EF = "/EF" # dictionary, containing a subset of the keys F, UF, DOS, Mac, and Unix
+ RF = "/RF" # dictionary, containing arrays of /EmbeddedFile
+ DESC = "/Desc" # description of the file
+ Cl = "/Cl"
+
+
+class StreamAttributes:
+ """
+ Table 4.2.
+ Table 5 in the 2.0 reference.
+ """
+
+ LENGTH = "/Length" # integer, required
+ FILTER = "/Filter" # name or array of names, optional
+ DECODE_PARMS = "/DecodeParms" # variable, optional -- 'decodeParams is wrong
+
+
+@unique
+class FilterTypes(StrEnum):
+ """§7.4 of the 1.7 and 2.0 references."""
+
+ ASCII_HEX_DECODE = "/ASCIIHexDecode" # abbreviation: AHx
+ ASCII_85_DECODE = "/ASCII85Decode" # abbreviation: A85
+ LZW_DECODE = "/LZWDecode" # abbreviation: LZW
+ FLATE_DECODE = "/FlateDecode" # abbreviation: Fl
+ RUN_LENGTH_DECODE = "/RunLengthDecode" # abbreviation: RL
+ CCITT_FAX_DECODE = "/CCITTFaxDecode" # abbreviation: CCF
+ DCT_DECODE = "/DCTDecode" # abbreviation: DCT
+ JPX_DECODE = "/JPXDecode"
+ JBIG2_DECODE = "/JBIG2Decode"
+
+
+class FilterTypeAbbreviations:
+ """§8.9.7 of the 1.7 and 2.0 references."""
+
+ AHx = "/AHx"
+ A85 = "/A85"
+ LZW = "/LZW"
+ FL = "/Fl"
+ RL = "/RL"
+ CCF = "/CCF"
+ DCT = "/DCT"
+
+
+class LzwFilterParameters:
+ """
+ Table 4.4.
+ Table 8 in the 2.0 reference.
+ """
+
+ PREDICTOR = "/Predictor" # integer
+ COLORS = "/Colors" # integer
+ BITS_PER_COMPONENT = "/BitsPerComponent" # integer
+ COLUMNS = "/Columns" # integer
+ EARLY_CHANGE = "/EarlyChange" # integer
+
+
+class CcittFaxDecodeParameters:
+ """
+ Table 4.5.
+ Table 11 in the 2.0 reference.
+ """
+
+ K = "/K" # integer
+ END_OF_LINE = "/EndOfLine" # boolean
+ ENCODED_BYTE_ALIGN = "/EncodedByteAlign" # boolean
+ COLUMNS = "/Columns" # integer
+ ROWS = "/Rows" # integer
+ END_OF_BLOCK = "/EndOfBlock" # boolean
+ BLACK_IS_1 = "/BlackIs1" # boolean
+ DAMAGED_ROWS_BEFORE_ERROR = "/DamagedRowsBeforeError" # integer
+
+
+class ImageAttributes:
+ """§11.6.5 of the 1.7 and 2.0 references."""
+
+ TYPE = "/Type" # name, required; must be /XObject
+ SUBTYPE = "/Subtype" # name, required; must be /Image
+ NAME = "/Name" # name, required
+ WIDTH = "/Width" # integer, required
+ HEIGHT = "/Height" # integer, required
+ BITS_PER_COMPONENT = "/BitsPerComponent" # integer, required
+ COLOR_SPACE = "/ColorSpace" # name, required
+ DECODE = "/Decode" # array, optional
+ INTENT = "/Intent" # string, optional
+ INTERPOLATE = "/Interpolate" # boolean, optional
+ IMAGE_MASK = "/ImageMask" # boolean, optional
+ MASK = "/Mask" # 1-bit image mask stream
+ S_MASK = "/SMask" # dictionary or name, optional
+
+
+class ColorSpaces:
+ DEVICE_RGB = "/DeviceRGB"
+ DEVICE_CMYK = "/DeviceCMYK"
+ DEVICE_GRAY = "/DeviceGray"
+
+
+class TypArguments:
+ """Table 8.2 of the PDF 1.7 reference."""
+
+ LEFT = "/Left"
+ RIGHT = "/Right"
+ BOTTOM = "/Bottom"
+ TOP = "/Top"
+
+
+class TypFitArguments:
+ """Table 8.2 of the PDF 1.7 reference."""
+
+ XYZ = "/XYZ"
+ FIT = "/Fit"
+ FIT_H = "/FitH"
+ FIT_V = "/FitV"
+ FIT_R = "/FitR"
+ FIT_B = "/FitB"
+ FIT_BH = "/FitBH"
+ FIT_BV = "/FitBV"
+
+
+class GoToActionArguments:
+ S = "/S" # name, required: type of action
+ D = "/D" # name, byte string, or array, required: destination to jump to
+ SD = "/SD" # array, optional: structure destination to jump to
+
+
+class AnnotationDictionaryAttributes:
+ """Table 8.15 Entries common to all annotation dictionaries."""
+
+ Type = "/Type"
+ Subtype = "/Subtype"
+ Rect = "/Rect"
+ Contents = "/Contents"
+ P = "/P"
+ NM = "/NM"
+ M = "/M"
+ F = "/F"
+ AP = "/AP"
+ AS = "/AS"
+ DA = "/DA"
+ Border = "/Border"
+ C = "/C"
+ StructParent = "/StructParent"
+ OC = "/OC"
+
+
+class InteractiveFormDictEntries:
+ Fields = "/Fields"
+ NeedAppearances = "/NeedAppearances"
+ SigFlags = "/SigFlags"
+ CO = "/CO"
+ DR = "/DR"
+ DA = "/DA"
+ Q = "/Q"
+ XFA = "/XFA"
+
+
+class FieldDictionaryAttributes:
+ """
+ Entries common to all field dictionaries (Table 8.69 PDF 1.7 reference)
+ (*very partially documented here*).
+
+ FFBits provides the constants used for `/Ff` from Table 8.70/8.75/8.77/8.79
+ """
+
+ FT = "/FT" # name, required for terminal fields
+ Parent = "/Parent" # dictionary, required for children
+ Kids = "/Kids" # array, sometimes required
+ T = "/T" # text string, optional
+ TU = "/TU" # text string, optional
+ TM = "/TM" # text string, optional
+ Ff = "/Ff" # integer, optional
+ V = "/V" # text string or array, optional
+ DV = "/DV" # text string, optional
+ AA = "/AA" # dictionary, optional
+ Opt = "/Opt" # array, optional
+
+ class FfBits(IntFlag):
+ """
+ Ease building /Ff flags
+ Some entries may be specific to:
+
+ * Text (Tx) (Table 8.75 PDF 1.7 reference)
+ * Buttons (Btn) (Table 8.77 PDF 1.7 reference)
+ * Choice (Ch) (Table 8.79 PDF 1.7 reference)
+ """
+
+ ReadOnly = 1 << 0
+ """common to Tx/Btn/Ch in Table 8.70"""
+ Required = 1 << 1
+ """common to Tx/Btn/Ch in Table 8.70"""
+ NoExport = 1 << 2
+ """common to Tx/Btn/Ch in Table 8.70"""
+
+ Multiline = 1 << 12
+ """Tx"""
+ Password = 1 << 13
+ """Tx"""
+
+ NoToggleToOff = 1 << 14
+ """Btn"""
+ Radio = 1 << 15
+ """Btn"""
+ Pushbutton = 1 << 16
+ """Btn"""
+
+ Combo = 1 << 17
+ """Ch"""
+ Edit = 1 << 18
+ """Ch"""
+ Sort = 1 << 19
+ """Ch"""
+
+ FileSelect = 1 << 20
+ """Tx"""
+
+ MultiSelect = 1 << 21
+ """Tx"""
+
+ DoNotSpellCheck = 1 << 22
+ """Tx/Ch"""
+ DoNotScroll = 1 << 23
+ """Tx"""
+ Comb = 1 << 24
+ """Tx"""
+
+ RadiosInUnison = 1 << 25
+ """Btn"""
+
+ RichText = 1 << 25
+ """Tx"""
+
+ CommitOnSelChange = 1 << 26
+ """Ch"""
+
+ @classmethod
+ def attributes(cls) -> tuple[str, ...]:
+ """
+ Get a tuple of all the attributes present in a Field Dictionary.
+
+ This method returns a tuple of all the attribute constants defined in
+ the FieldDictionaryAttributes class. These attributes correspond to the
+ entries that are common to all field dictionaries as specified in the
+ PDF 1.7 reference.
+
+ Returns:
+ A tuple containing all the attribute constants.
+
+ """
+ return (
+ cls.TM,
+ cls.T,
+ cls.FT,
+ cls.Parent,
+ cls.TU,
+ cls.Ff,
+ cls.V,
+ cls.DV,
+ cls.Kids,
+ cls.AA,
+ )
+
+ @classmethod
+ def attributes_dict(cls) -> dict[str, str]:
+ """
+ Get a dictionary of attribute keys and their human-readable names.
+
+ This method returns a dictionary where the keys are the attribute
+ constants defined in the FieldDictionaryAttributes class and the values
+ are their corresponding human-readable names. These attributes
+ correspond to the entries that are common to all field dictionaries as
+ specified in the PDF 1.7 reference.
+
+ Returns:
+ A dictionary containing attribute keys and their names.
+
+ """
+ return {
+ cls.FT: "Field Type",
+ cls.Parent: "Parent",
+ cls.T: "Field Name",
+ cls.TU: "Alternate Field Name",
+ cls.TM: "Mapping Name",
+ cls.Ff: "Field Flags",
+ cls.V: "Value",
+ cls.DV: "Default Value",
+ }
+
+
+class CheckboxRadioButtonAttributes:
+ """Table 8.76 Field flags common to all field types."""
+
+ Opt = "/Opt" # Options, Optional
+
+ @classmethod
+ def attributes(cls) -> tuple[str, ...]:
+ """
+ Get a tuple of all the attributes present in a Field Dictionary.
+
+ This method returns a tuple of all the attribute constants defined in
+ the CheckboxRadioButtonAttributes class. These attributes correspond to
+ the entries that are common to all field dictionaries as specified in
+ the PDF 1.7 reference.
+
+ Returns:
+ A tuple containing all the attribute constants.
+
+ """
+ return (cls.Opt,)
+
+ @classmethod
+ def attributes_dict(cls) -> dict[str, str]:
+ """
+ Get a dictionary of attribute keys and their human-readable names.
+
+ This method returns a dictionary where the keys are the attribute
+ constants defined in the CheckboxRadioButtonAttributes class and the
+ values are their corresponding human-readable names. These attributes
+ correspond to the entries that are common to all field dictionaries as
+ specified in the PDF 1.7 reference.
+
+ Returns:
+ A dictionary containing attribute keys and their names.
+
+ """
+ return {
+ cls.Opt: "Options",
+ }
+
+
+class FieldFlag(IntFlag):
+ """Table 8.70 Field flags common to all field types."""
+
+ READ_ONLY = 1
+ REQUIRED = 2
+ NO_EXPORT = 4
+
+
+class DocumentInformationAttributes:
+ """Table 10.2 Entries in the document information dictionary."""
+
+ TITLE = "/Title" # text string, optional
+ AUTHOR = "/Author" # text string, optional
+ SUBJECT = "/Subject" # text string, optional
+ KEYWORDS = "/Keywords" # text string, optional
+ CREATOR = "/Creator" # text string, optional
+ PRODUCER = "/Producer" # text string, optional
+ CREATION_DATE = "/CreationDate" # date, optional
+ MOD_DATE = "/ModDate" # date, optional
+ TRAPPED = "/Trapped" # name, optional
+
+
+class PageLayouts:
+ """
+ Page 84, PDF 1.4 reference.
+ Page 115, PDF 2.0 reference.
+ """
+
+ SINGLE_PAGE = "/SinglePage"
+ ONE_COLUMN = "/OneColumn"
+ TWO_COLUMN_LEFT = "/TwoColumnLeft"
+ TWO_COLUMN_RIGHT = "/TwoColumnRight"
+ TWO_PAGE_LEFT = "/TwoPageLeft" # (PDF 1.5)
+ TWO_PAGE_RIGHT = "/TwoPageRight" # (PDF 1.5)
+
+
+class GraphicsStateParameters:
+ """Table 58 – Entries in a Graphics State Parameter Dictionary"""
+
+ TYPE = "/Type" # name, optional
+ LW = "/LW" # number, optional
+ LC = "/LC" # integer, optional
+ LJ = "/LJ" # integer, optional
+ ML = "/ML" # number, optional
+ D = "/D" # array, optional
+ RI = "/RI" # name, optional
+ OP = "/OP"
+ op = "/op"
+ OPM = "/OPM"
+ FONT = "/Font" # array, optional
+ BG = "/BG"
+ BG2 = "/BG2"
+ UCR = "/UCR"
+ UCR2 = "/UCR2"
+ TR = "/TR"
+ TR2 = "/TR2"
+ HT = "/HT"
+ FL = "/FL"
+ SM = "/SM"
+ SA = "/SA"
+ BM = "/BM"
+ S_MASK = "/SMask" # dictionary or name, optional
+ CA = "/CA"
+ ca = "/ca"
+ AIS = "/AIS"
+ TK = "/TK"
+
+
+class CatalogDictionary:
+ """§7.7.2 of the 1.7 and 2.0 references."""
+
+ TYPE = "/Type" # name, required; must be /Catalog
+ VERSION = "/Version" # name
+ EXTENSIONS = "/Extensions" # dictionary, optional; ISO 32000-1
+ PAGES = "/Pages" # dictionary, required
+ PAGE_LABELS = "/PageLabels" # number tree, optional
+ NAMES = "/Names" # dictionary, optional
+ DESTS = "/Dests" # dictionary, optional
+ VIEWER_PREFERENCES = "/ViewerPreferences" # dictionary, optional
+ PAGE_LAYOUT = "/PageLayout" # name, optional
+ PAGE_MODE = "/PageMode" # name, optional
+ OUTLINES = "/Outlines" # dictionary, optional
+ THREADS = "/Threads" # array, optional
+ OPEN_ACTION = "/OpenAction" # array or dictionary or name, optional
+ AA = "/AA" # dictionary, optional
+ URI = "/URI" # dictionary, optional
+ ACRO_FORM = "/AcroForm" # dictionary, optional
+ METADATA = "/Metadata" # stream, optional
+ STRUCT_TREE_ROOT = "/StructTreeRoot" # dictionary, optional
+ MARK_INFO = "/MarkInfo" # dictionary, optional
+ LANG = "/Lang" # text string, optional
+ SPIDER_INFO = "/SpiderInfo" # dictionary, optional
+ OUTPUT_INTENTS = "/OutputIntents" # array, optional
+ PIECE_INFO = "/PieceInfo" # dictionary, optional
+ OC_PROPERTIES = "/OCProperties" # dictionary, optional
+ PERMS = "/Perms" # dictionary, optional
+ LEGAL = "/Legal" # dictionary, optional
+ REQUIREMENTS = "/Requirements" # array, optional
+ COLLECTION = "/Collection" # dictionary, optional
+ NEEDS_RENDERING = "/NeedsRendering" # boolean, optional
+ DSS = "/DSS" # dictionary, optional
+ AF = "/AF" # array of dictionaries, optional
+ D_PART_ROOT = "/DPartRoot" # dictionary, optional
+
+
+class OutlineFontFlag(IntFlag):
+ """A class used as an enumerable flag for formatting an outline font."""
+
+ italic = 1
+ bold = 2
+
+
+class PageLabelStyle:
+ """
+ Table 8.10 in the 1.7 reference.
+ Table 161 in the 2.0 reference.
+ """
+
+ DECIMAL = "/D" # Decimal Arabic numerals
+ UPPERCASE_ROMAN = "/R" # Uppercase Roman numerals
+ LOWERCASE_ROMAN = "/r" # Lowercase Roman numerals
+ UPPERCASE_LETTER = "/A" # Uppercase letters
+ LOWERCASE_LETTER = "/a" # Lowercase letters
+
+
+class AnnotationFlag(IntFlag):
+ """See §12.5.3 "Annotation Flags"."""
+
+ INVISIBLE = 1
+ HIDDEN = 2
+ PRINT = 4
+ NO_ZOOM = 8
+ NO_ROTATE = 16
+ NO_VIEW = 32
+ READ_ONLY = 64
+ LOCKED = 128
+ TOGGLE_NO_VIEW = 256
+ LOCKED_CONTENTS = 512
+
+
+PDF_KEYS = (
+ AnnotationDictionaryAttributes,
+ CatalogAttributes,
+ CatalogDictionary,
+ CcittFaxDecodeParameters,
+ CheckboxRadioButtonAttributes,
+ ColorSpaces,
+ Core,
+ DocumentInformationAttributes,
+ EncryptionDictAttributes,
+ FieldDictionaryAttributes,
+ FileSpecificationDictionaryEntries,
+ FilterTypeAbbreviations,
+ FilterTypes,
+ GoToActionArguments,
+ GraphicsStateParameters,
+ ImageAttributes,
+ InteractiveFormDictEntries,
+ LzwFilterParameters,
+ PageAttributes,
+ PageLayouts,
+ PagesAttributes,
+ Resources,
+ StreamAttributes,
+ TrailerKeys,
+ TypArguments,
+ TypFitArguments,
+)
+
+
+class ImageType(IntFlag):
+ NONE = 0
+ XOBJECT_IMAGES = auto()
+ INLINE_IMAGES = auto()
+ DRAWING_IMAGES = auto()
+ ALL = XOBJECT_IMAGES | INLINE_IMAGES | DRAWING_IMAGES
+ IMAGES = ALL # for consistency with ObjectDeletionFlag
+
+
+_INLINE_IMAGE_VALUE_MAPPING = {
+ "/G": "/DeviceGray",
+ "/RGB": "/DeviceRGB",
+ "/CMYK": "/DeviceCMYK",
+ "/I": "/Indexed",
+ "/AHx": "/ASCIIHexDecode",
+ "/A85": "/ASCII85Decode",
+ "/LZW": "/LZWDecode",
+ "/Fl": "/FlateDecode",
+ "/RL": "/RunLengthDecode",
+ "/CCF": "/CCITTFaxDecode",
+ "/DCT": "/DCTDecode",
+ "/DeviceGray": "/DeviceGray",
+ "/DeviceRGB": "/DeviceRGB",
+ "/DeviceCMYK": "/DeviceCMYK",
+ "/Indexed": "/Indexed",
+ "/ASCIIHexDecode": "/ASCIIHexDecode",
+ "/ASCII85Decode": "/ASCII85Decode",
+ "/LZWDecode": "/LZWDecode",
+ "/FlateDecode": "/FlateDecode",
+ "/RunLengthDecode": "/RunLengthDecode",
+ "/CCITTFaxDecode": "/CCITTFaxDecode",
+ "/DCTDecode": "/DCTDecode",
+ "/RelativeColorimetric": "/RelativeColorimetric",
+}
+
+_INLINE_IMAGE_KEY_MAPPING = {
+ "/BPC": "/BitsPerComponent",
+ "/CS": "/ColorSpace",
+ "/D": "/Decode",
+ "/DP": "/DecodeParms",
+ "/F": "/Filter",
+ "/H": "/Height",
+ "/W": "/Width",
+ "/I": "/Interpolate",
+ "/Intent": "/Intent",
+ "/IM": "/ImageMask",
+ "/BitsPerComponent": "/BitsPerComponent",
+ "/ColorSpace": "/ColorSpace",
+ "/Decode": "/Decode",
+ "/DecodeParms": "/DecodeParms",
+ "/Filter": "/Filter",
+ "/Height": "/Height",
+ "/Width": "/Width",
+ "/Interpolate": "/Interpolate",
+ "/ImageMask": "/ImageMask",
+}
+
+
+class AFRelationship:
+ """
+ Associated file relationship types, defining the relationship between
+ the PDF component and the associated file.
+
+ Defined in table 43 of the PDF 2.0 reference.
+ """
+
+ SOURCE = "/Source" # Original content source
+ DATA = "/Data" # Base data for visual presentation
+ ALTERNATIVE = "/Alternative" # Alternative content representation
+ SUPPLEMENT = "/Supplement" # Supplemental representation of original source/data
+ ENCRYPTED_PAYLOAD = "/EncryptedPayload" # Encrypted payload document
+ FORM_DATA = "/FormData" # Data associated with AcroForm of this PDF
+ SCHEMA = "/Schema" # Schema definition for associated object
+ UNSPECIFIED = "/Unspecified" # Not known or cannot be described with values
+
+
+class BorderStyles:
+ """
+ A class defining border styles used in PDF documents.
+
+ Defined in table 168 of the PDF 2.0 reference.
+ """
+
+ BEVELED = "/B"
+ DASHED = "/D"
+ INSET = "/I"
+ SOLID = "/S"
+ UNDERLINED = "/U"
diff --git a/venv/lib/python3.12/site-packages/pypdf/errors.py b/venv/lib/python3.12/site-packages/pypdf/errors.py
new file mode 100644
index 0000000..8fec6e1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/errors.py
@@ -0,0 +1,74 @@
+"""
+All errors/exceptions pypdf raises and all of the warnings it uses.
+
+Please note that broken PDF files might cause other Exceptions.
+"""
+
+
+class DeprecationError(Exception):
+ """Raised when a deprecated feature is used."""
+
+
+class DependencyError(Exception):
+ """
+ Raised when a required dependency (a library or module that pypdf depends on)
+ is not available or cannot be imported.
+ """
+
+
+class PyPdfError(Exception):
+ """Base class for all exceptions raised by pypdf."""
+
+
+class PdfReadError(PyPdfError):
+ """Raised when there is an issue reading a PDF file."""
+
+
+class PageSizeNotDefinedError(PyPdfError):
+ """Raised when the page size of a PDF document is not defined."""
+
+
+class PdfReadWarning(UserWarning):
+ """Issued when there is a potential issue reading a PDF file, but it can still be read."""
+
+
+class PdfStreamError(PdfReadError):
+ """Raised when there is an issue reading the stream of data in a PDF file."""
+
+
+class ParseError(PyPdfError):
+ """
+ Raised when there is an issue parsing (analyzing and understanding the
+ structure and meaning of) a PDF file.
+ """
+
+
+class FileNotDecryptedError(PdfReadError):
+ """
+ Raised when a PDF file that has been encrypted
+ (meaning it requires a password to be accessed) has not been successfully
+ decrypted.
+ """
+
+
+class WrongPasswordError(FileNotDecryptedError):
+ """Raised when the wrong password is used to try to decrypt an encrypted PDF file."""
+
+
+class EmptyFileError(PdfReadError):
+ """Raised when a PDF file is empty or has no content."""
+
+
+class EmptyImageDataError(PyPdfError):
+ """Raised when trying to process an image that has no data."""
+
+
+STREAM_TRUNCATED_PREMATURELY = "Stream has ended unexpectedly"
+
+
+class LimitReachedError(PyPdfError):
+ """Raised when a limit is reached."""
+
+
+class XmpDocumentError(PyPdfError, RuntimeError):
+ """Raised when the XMP XML document context is invalid or missing."""
diff --git a/venv/lib/python3.12/site-packages/pypdf/filters.py b/venv/lib/python3.12/site-packages/pypdf/filters.py
new file mode 100644
index 0000000..d07f309
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/filters.py
@@ -0,0 +1,815 @@
+# Copyright (c) 2006, Mathieu Fenniak
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+
+
+"""
+Implementation of stream filters; §7.4 Filters of the PDF 2.0 specification.
+
+§8.9.7 Inline images of the PDF 2.0 specification has abbreviations that can be
+used for the names of filters in an inline image object.
+"""
+__author__ = "Mathieu Fenniak"
+__author_email__ = "biziqe@mathieu.fenniak.net"
+
+import math
+import os
+import shutil
+import struct
+import subprocess
+import zlib
+from base64 import a85decode
+from dataclasses import dataclass
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import Any, Optional, Union, cast
+
+from ._codecs._codecs import LzwCodec as _LzwCodec
+from ._utils import (
+ WHITESPACES_AS_BYTES,
+ deprecation_with_replacement,
+ logger_warning,
+)
+from .constants import CcittFaxDecodeParameters as CCITT
+from .constants import FilterTypeAbbreviations as FTA
+from .constants import FilterTypes as FT
+from .constants import ImageAttributes as IA
+from .constants import LzwFilterParameters as LZW
+from .constants import StreamAttributes as SA
+from .errors import DependencyError, LimitReachedError, PdfReadError, PdfStreamError
+from .generic import (
+ ArrayObject,
+ DictionaryObject,
+ IndirectObject,
+ NullObject,
+ StreamObject,
+ is_null_or_none,
+)
+
+JBIG2_MAX_OUTPUT_LENGTH = 75_000_000
+LZW_MAX_OUTPUT_LENGTH = 75_000_000
+ZLIB_MAX_OUTPUT_LENGTH = 75_000_000
+
+
+
+def _decompress_with_limit(data: bytes) -> bytes:
+ decompressor = zlib.decompressobj()
+ result = decompressor.decompress(data, max_length=ZLIB_MAX_OUTPUT_LENGTH)
+ if decompressor.unconsumed_tail:
+ raise LimitReachedError(
+ f"Limit reached while decompressing. {len(decompressor.unconsumed_tail)} bytes remaining."
+ )
+ return result
+
+
+def decompress(data: bytes) -> bytes:
+ """
+ Decompress the given data using zlib.
+
+ Attempts to decompress the input data using zlib.
+ If the decompression fails due to a zlib error, it falls back
+ to using a decompression object with a larger window size.
+
+ Please note that the output length is limited to avoid memory
+ issues. If you need to process larger content streams, consider
+ adapting ``pypdf.filters.ZLIB_MAX_OUTPUT_LENGTH``. In case you
+ are only dealing with trusted inputs and/or want to disable these
+ limits, set the value to `0`.
+
+ Args:
+ data: The input data to be decompressed.
+
+ Returns:
+ The decompressed data.
+
+ """
+ try:
+ return _decompress_with_limit(data)
+ except zlib.error:
+ # First quick approach: There are known issues with faulty added bytes to the
+ # tail of the encoded stream from early Adobe Distiller or Pitstop versions
+ # with CR char as the default line separator (assumed by reverse engineering)
+ # that breaks the decoding process in the end.
+ #
+ # Try first to cut off some of the tail byte by byte, but limited to not
+ # iterate through too many loops and kill the performance for large streams,
+ # to then allow the final fallback to run. Added this intermediate attempt,
+ # because starting from the head of the stream byte by byte kills completely
+ # the performance for large streams (e.g., 6 MB) with the tail-byte-issue
+ # and takes ages. This solution is really fast:
+ max_tail_cut_off_bytes: int = 8
+ for i in range(1, min(max_tail_cut_off_bytes + 1, len(data))):
+ try:
+ return _decompress_with_limit(data[:-i])
+ except zlib.error:
+ pass
+
+ # If still failing, then try with increased window size.
+ decompressor = zlib.decompressobj(zlib.MAX_WBITS | 32)
+ result_str = b""
+ remaining_limit = ZLIB_MAX_OUTPUT_LENGTH
+ data_single_bytes = [data[i : i + 1] for i in range(len(data))]
+ known_errors = set()
+ for index, b in enumerate(data_single_bytes):
+ try:
+ decompressed = decompressor.decompress(b, max_length=remaining_limit)
+ result_str += decompressed
+ remaining_limit -= len(decompressed)
+ if remaining_limit <= 0:
+ raise LimitReachedError(
+ f"Limit reached while decompressing. {len(data_single_bytes) - index} bytes remaining."
+ )
+ except zlib.error as error:
+ error_str = str(error)
+ if error_str in known_errors:
+ continue
+ logger_warning(error_str, __name__)
+ known_errors.add(error_str)
+ return result_str
+
+
+class FlateDecode:
+ @staticmethod
+ def decode(
+ data: bytes,
+ decode_parms: Optional[DictionaryObject] = None,
+ **kwargs: Any,
+ ) -> bytes:
+ """
+ Decode data which is flate-encoded.
+
+ Args:
+ data: flate-encoded data.
+ decode_parms: a dictionary of values, understanding the
+ "/Predictor": key only
+
+ Returns:
+ The flate-decoded data.
+
+ Raises:
+ PdfReadError:
+
+ """
+ str_data = decompress(data)
+ predictor = 1
+
+ if decode_parms:
+ try:
+ predictor = decode_parms.get("/Predictor", 1)
+ except (AttributeError, TypeError): # Type Error is NullObject
+ pass # Usually an array with a null object was read
+ # predictor 1 == no predictor
+ if predictor != 1:
+ # /Columns, the number of samples in each row, has a default value of 1;
+ # §7.4.4.3, ISO 32000.
+ DEFAULT_BITS_PER_COMPONENT = 8
+ try:
+ columns = cast(int, decode_parms[LZW.COLUMNS].get_object()) # type: ignore
+ except (TypeError, KeyError):
+ columns = 1
+ try:
+ colors = cast(int, decode_parms[LZW.COLORS].get_object()) # type: ignore
+ except (TypeError, KeyError):
+ colors = 1
+ try:
+ bits_per_component = cast(
+ int,
+ decode_parms[LZW.BITS_PER_COMPONENT].get_object(), # type: ignore
+ )
+ except (TypeError, KeyError):
+ bits_per_component = DEFAULT_BITS_PER_COMPONENT
+
+ # PNG predictor can vary by row and so is the lead byte on each row
+ rowlength = (
+ math.ceil(columns * colors * bits_per_component / 8) + 1
+ ) # number of bytes
+
+ # TIFF prediction:
+ if predictor == 2:
+ rowlength -= 1 # remove the predictor byte
+ bpp = rowlength // columns
+ str_data = bytearray(str_data)
+ for i in range(len(str_data)):
+ if i % rowlength >= bpp:
+ str_data[i] = (str_data[i] + str_data[i - bpp]) % 256
+ str_data = bytes(str_data)
+ # PNG prediction:
+ elif 10 <= predictor <= 15:
+ str_data = FlateDecode._decode_png_prediction(
+ str_data, columns, rowlength
+ )
+ else:
+ raise PdfReadError(f"Unsupported flatedecode predictor {predictor!r}")
+ return str_data
+
+ @staticmethod
+ def _decode_png_prediction(data: bytes, columns: int, rowlength: int) -> bytes:
+ # PNG prediction can vary from row to row
+ if (remainder := len(data) % rowlength) != 0:
+ logger_warning("Image data is not rectangular. Adding padding.", __name__)
+ data += b"\x00" * (rowlength - remainder)
+ assert len(data) % rowlength == 0
+ output = []
+ prev_rowdata = (0,) * rowlength
+ bpp = (rowlength - 1) // columns # recomputed locally to not change params
+ for row in range(0, len(data), rowlength):
+ rowdata: list[int] = list(data[row : row + rowlength])
+ filter_byte = rowdata[0]
+
+ if filter_byte == 0:
+ # PNG None Predictor
+ pass
+ elif filter_byte == 1:
+ # PNG Sub Predictor
+ for i in range(bpp + 1, rowlength):
+ rowdata[i] = (rowdata[i] + rowdata[i - bpp]) % 256
+ elif filter_byte == 2:
+ # PNG Up Predictor
+ for i in range(1, rowlength):
+ rowdata[i] = (rowdata[i] + prev_rowdata[i]) % 256
+ elif filter_byte == 3:
+ # PNG Average Predictor
+ for i in range(1, bpp + 1):
+ floor = prev_rowdata[i] // 2
+ rowdata[i] = (rowdata[i] + floor) % 256
+ for i in range(bpp + 1, rowlength):
+ left = rowdata[i - bpp]
+ floor = (left + prev_rowdata[i]) // 2
+ rowdata[i] = (rowdata[i] + floor) % 256
+ elif filter_byte == 4:
+ # PNG Paeth Predictor
+ for i in range(1, bpp + 1):
+ rowdata[i] = (rowdata[i] + prev_rowdata[i]) % 256
+ for i in range(bpp + 1, rowlength):
+ left = rowdata[i - bpp]
+ up = prev_rowdata[i]
+ up_left = prev_rowdata[i - bpp]
+
+ p = left + up - up_left
+ dist_left = abs(p - left)
+ dist_up = abs(p - up)
+ dist_up_left = abs(p - up_left)
+
+ if dist_left <= dist_up and dist_left <= dist_up_left:
+ paeth = left
+ elif dist_up <= dist_up_left:
+ paeth = up
+ else:
+ paeth = up_left
+
+ rowdata[i] = (rowdata[i] + paeth) % 256
+ else:
+ raise PdfReadError(
+ f"Unsupported PNG filter {filter_byte!r}"
+ ) # pragma: no cover
+ prev_rowdata = tuple(rowdata)
+ output.extend(rowdata[1:])
+ return bytes(output)
+
+ @staticmethod
+ def encode(data: bytes, level: int = -1) -> bytes:
+ """
+ Compress the input data using zlib.
+
+ Args:
+ data: The data to be compressed.
+ level: See https://docs.python.org/3/library/zlib.html#zlib.compress
+
+ Returns:
+ The compressed data.
+
+ """
+ return zlib.compress(data, level)
+
+
+class ASCIIHexDecode:
+ """
+ The ASCIIHexDecode filter decodes data that has been encoded in ASCII
+ hexadecimal form into a base-7 ASCII format.
+ """
+
+ @staticmethod
+ def decode(
+ data: Union[str, bytes],
+ decode_parms: Optional[DictionaryObject] = None,
+ **kwargs: Any,
+ ) -> bytes:
+ """
+ Decode an ASCII-Hex encoded data stream.
+
+ Args:
+ data: a str sequence of hexadecimal-encoded values to be
+ converted into a base-7 ASCII string
+ decode_parms: this filter does not use parameters.
+
+ Returns:
+ A string conversion in base-7 ASCII, where each of its values
+ v is such that 0 <= ord(v) <= 127.
+
+ Raises:
+ PdfStreamError:
+
+ """
+ if isinstance(data, str):
+ data = data.encode()
+ retval = b""
+ hex_pair = b""
+ index = 0
+ while True:
+ if index >= len(data):
+ logger_warning(
+ "missing EOD in ASCIIHexDecode, check if output is OK", __name__
+ )
+ break # Reached end of string without an EOD
+ char = data[index : index + 1]
+ if char == b">":
+ break
+ if char.isspace():
+ index += 1
+ continue
+ hex_pair += char
+ if len(hex_pair) == 2:
+ retval += bytes((int(hex_pair, base=16),))
+ hex_pair = b""
+ index += 1
+ # If the filter encounters the EOD marker after reading
+ # an odd number of hexadecimal digits,
+ # it shall behave as if a 0 (zero) followed the last digit.
+ # For every even number of hexadecimal digits, hex_pair is reset to b"".
+ if hex_pair != b"":
+ hex_pair += b"0"
+ retval += bytes((int(hex_pair, base=16),))
+ return retval
+
+
+class RunLengthDecode:
+ """
+ The RunLengthDecode filter decodes data that has been encoded in a
+ simple byte-oriented format based on run length.
+ The encoded data is a sequence of runs, where each run consists of
+ a length byte followed by 1 to 128 bytes of data. If the length byte is
+ in the range 0 to 127,
+ the following length + 1 (1 to 128) bytes are copied literally during
+ decompression.
+ If length is in the range 129 to 255, the following single byte is to be
+ copied 257 − length (2 to 128) times during decompression. A length value
+ of 128 denotes EOD.
+ """
+
+ @staticmethod
+ def decode(
+ data: bytes,
+ decode_parms: Optional[DictionaryObject] = None,
+ **kwargs: Any,
+ ) -> bytes:
+ """
+ Decode a run length encoded data stream.
+
+ Args:
+ data: a bytes sequence of length/data
+ decode_parms: this filter does not use parameters.
+
+ Returns:
+ A bytes decompressed sequence.
+
+ Raises:
+ PdfStreamError:
+
+ """
+ lst = []
+ index = 0
+ while True:
+ if index >= len(data):
+ logger_warning(
+ "missing EOD in RunLengthDecode, check if output is OK", __name__
+ )
+ break # Reached end of string without an EOD
+ length = data[index]
+ index += 1
+ if length == 128:
+ data_length = len(data)
+ if index < data_length:
+ # We should first check, if we have an inner stream from a multi-encoded
+ # stream with a faulty trailing newline that we can decode properly.
+ # We will just ignore the last byte and raise a warning ...
+ if (index == data_length - 1) and (data[index : index + 1] == b"\n"):
+ logger_warning(
+ "Found trailing newline in stream data, check if output is OK", __name__
+ )
+ break
+ # Raising an exception here breaks all image extraction for this file, which might
+ # not be desirable. For this reason, indicate that the output is most likely wrong,
+ # as processing stopped after the first EOD marker. See issue #3517.
+ logger_warning(
+ "Early EOD in RunLengthDecode, check if output is OK", __name__
+ )
+ break
+ if length < 128:
+ length += 1
+ lst.append(data[index : (index + length)])
+ index += length
+ else: # >128
+ length = 257 - length
+ lst.append(bytes((data[index],)) * length)
+ index += 1
+ return b"".join(lst)
+
+
+class LZWDecode:
+ class Decoder:
+ STOP = 257
+ CLEARDICT = 256
+
+ def __init__(self, data: bytes) -> None:
+ self.data = data
+
+ def decode(self) -> bytes:
+ return _LzwCodec(max_output_length=LZW_MAX_OUTPUT_LENGTH).decode(self.data)
+
+ @staticmethod
+ def decode(
+ data: bytes,
+ decode_parms: Optional[DictionaryObject] = None,
+ **kwargs: Any,
+ ) -> bytes:
+ """
+ Decode an LZW encoded data stream.
+
+ Args:
+ data: ``bytes`` or ``str`` text to decode.
+ decode_parms: a dictionary of parameter values.
+
+ Returns:
+ decoded data.
+
+ """
+ # decode_parms is unused here
+ return LZWDecode.Decoder(data).decode()
+
+
+class ASCII85Decode:
+ """Decodes string ASCII85-encoded data into a byte format."""
+
+ @staticmethod
+ def decode(
+ data: Union[str, bytes],
+ decode_parms: Optional[DictionaryObject] = None,
+ **kwargs: Any,
+ ) -> bytes:
+ """
+ Decode an Ascii85 encoded data stream.
+
+ Args:
+ data: ``bytes`` or ``str`` text to decode.
+ decode_parms: this filter does not use parameters.
+
+ Returns:
+ decoded data.
+
+ """
+ if isinstance(data, str):
+ data = data.encode()
+ data = data.strip(WHITESPACES_AS_BYTES)
+ if len(data) > 2 and data.endswith(b">"):
+ data = data[:-1].rstrip(WHITESPACES_AS_BYTES) + data[-1:]
+ try:
+ return a85decode(data, adobe=True, ignorechars=WHITESPACES_AS_BYTES)
+ except ValueError as error:
+ if error.args[0] == "Ascii85 encoded byte sequences must end with b'~>'":
+ logger_warning("Ignoring missing Ascii85 end marker.", __name__)
+ return a85decode(data, adobe=False, ignorechars=WHITESPACES_AS_BYTES)
+ raise
+
+
+class DCTDecode:
+ @staticmethod
+ def decode(
+ data: bytes,
+ decode_parms: Optional[DictionaryObject] = None,
+ **kwargs: Any,
+ ) -> bytes:
+ """
+ Decompresses data encoded using a DCT (discrete cosine transform)
+ technique based on the JPEG standard (IS0/IEC 10918),
+ reproducing image sample data that approximates the original data.
+
+ Args:
+ data: text to decode.
+ decode_parms: this filter does not use parameters.
+
+ Returns:
+ decoded data.
+
+ """
+ return data
+
+
+class JPXDecode:
+ @staticmethod
+ def decode(
+ data: bytes,
+ decode_parms: Optional[DictionaryObject] = None,
+ **kwargs: Any,
+ ) -> bytes:
+ """
+ Decompresses data encoded using the wavelet-based JPEG 2000 standard,
+ reproducing the original image data.
+
+ Args:
+ data: text to decode.
+ decode_parms: this filter does not use parameters.
+
+ Returns:
+ decoded data.
+
+ """
+ return data
+
+
+@dataclass
+class CCITTParameters:
+ """§7.4.6, optional parameters for the CCITTFaxDecode filter."""
+
+ K: int = 0
+ columns: int = 1728
+ rows: int = 0
+ EndOfLine: Union[bool, None] = False
+ EncodedByteAlign: Union[bool, None] = False
+ EndOfBlock: Union[bool, None] = True
+ BlackIs1: bool = False
+ DamagedRowsBeforeError: Union[int, None] = 0
+
+ @property
+ def group(self) -> int:
+ if self.K < 0:
+ # Pure two-dimensional encoding (Group 4)
+ CCITTgroup = 4
+ else:
+ # K == 0: Pure one-dimensional encoding (Group 3, 1-D)
+ # K > 0: Mixed one- and two-dimensional encoding (Group 3, 2-D)
+ CCITTgroup = 3
+ return CCITTgroup
+
+
+def __create_old_class_instance(
+ K: int = 0,
+ columns: int = 0,
+ rows: int = 0
+) -> CCITTParameters:
+ deprecation_with_replacement("CCITParameters", "CCITTParameters", "6.0.0")
+ return CCITTParameters(K, columns, rows)
+
+
+# Create an alias for the old class name
+CCITParameters = __create_old_class_instance
+
+
+class CCITTFaxDecode:
+ """
+ §7.4.6, CCITTFaxDecode filter (ISO 32000).
+
+ Either Group 3 or Group 4 CCITT facsimile (fax) encoding.
+ CCITT encoding is bit-oriented, not byte-oriented.
+
+ §7.4.6, optional parameters for the CCITTFaxDecode filter.
+ """
+
+ @staticmethod
+ def _get_parameters(
+ parameters: Union[None, ArrayObject, DictionaryObject, IndirectObject],
+ rows: Union[int, IndirectObject],
+ ) -> CCITTParameters:
+ ccitt_parameters = CCITTParameters(rows=int(rows))
+ if parameters:
+ parameters_unwrapped = cast(
+ Union[ArrayObject, DictionaryObject], parameters.get_object()
+ )
+ if isinstance(parameters_unwrapped, ArrayObject):
+ for decode_parm in parameters_unwrapped:
+ if CCITT.K in decode_parm:
+ ccitt_parameters.K = decode_parm[CCITT.K].get_object()
+ if CCITT.COLUMNS in decode_parm:
+ ccitt_parameters.columns = decode_parm[CCITT.COLUMNS].get_object()
+ if CCITT.BLACK_IS_1 in decode_parm:
+ ccitt_parameters.BlackIs1 = decode_parm[CCITT.BLACK_IS_1].get_object().value
+ else:
+ if CCITT.K in parameters_unwrapped:
+ ccitt_parameters.K = parameters_unwrapped[CCITT.K].get_object() # type: ignore
+ if CCITT.COLUMNS in parameters_unwrapped:
+ ccitt_parameters.columns = parameters_unwrapped[CCITT.COLUMNS].get_object() # type: ignore
+ if CCITT.BLACK_IS_1 in parameters_unwrapped:
+ ccitt_parameters.BlackIs1 = parameters_unwrapped[CCITT.BLACK_IS_1].get_object().value # type: ignore
+ return ccitt_parameters
+
+ @staticmethod
+ def decode(
+ data: bytes,
+ decode_parms: Optional[DictionaryObject] = None,
+ height: int = 0,
+ **kwargs: Any,
+ ) -> bytes:
+ params = CCITTFaxDecode._get_parameters(decode_parms, height)
+
+ img_size = len(data)
+ tiff_header_struct = "<2shlh" + "hhll" * 8 + "h"
+ tiff_header = struct.pack(
+ tiff_header_struct,
+ b"II", # Byte order indication: Little endian
+ 42, # Version number (always 42)
+ 8, # Offset to the first image file directory (IFD)
+ 8, # Number of tags in IFD
+ 256, # ImageWidth, LONG, 1, width
+ 4,
+ 1,
+ params.columns,
+ 257, # ImageLength, LONG, 1, length
+ 4,
+ 1,
+ params.rows,
+ 258, # BitsPerSample, SHORT, 1, 1
+ 3,
+ 1,
+ 1,
+ 259, # Compression, SHORT, 1, compression Type
+ 3,
+ 1,
+ params.group,
+ 262, # Thresholding, SHORT, 1, 0 = BlackIs1
+ 3,
+ 1,
+ int(params.BlackIs1),
+ 273, # StripOffsets, LONG, 1, length of header
+ 4,
+ 1,
+ struct.calcsize(
+ tiff_header_struct
+ ),
+ 278, # RowsPerStrip, LONG, 1, length
+ 4,
+ 1,
+ params.rows,
+ 279, # StripByteCounts, LONG, 1, size of image
+ 4,
+ 1,
+ img_size,
+ 0, # last IFD
+ )
+
+ return tiff_header + data
+
+
+JBIG2DEC_BINARY = shutil.which("jbig2dec")
+
+
+class JBIG2Decode:
+ @staticmethod
+ def decode(
+ data: bytes,
+ decode_parms: Optional[DictionaryObject] = None,
+ **kwargs: Any,
+ ) -> bytes:
+ if JBIG2DEC_BINARY is None:
+ raise DependencyError("jbig2dec binary is not available.")
+
+ with TemporaryDirectory() as tempdir:
+ directory = Path(tempdir)
+ paths: list[Path] = []
+
+ if decode_parms and "/JBIG2Globals" in decode_parms:
+ jbig2_globals = decode_parms["/JBIG2Globals"]
+ if not is_null_or_none(jbig2_globals) and not is_null_or_none(pointer := jbig2_globals.get_object()):
+ assert pointer is not None, "mypy"
+ if isinstance(pointer, StreamObject):
+ path = directory.joinpath("globals.jbig2")
+ path.write_bytes(pointer.get_data())
+ paths.append(path)
+
+ path = directory.joinpath("image.jbig2")
+ path.write_bytes(data)
+ paths.append(path)
+
+ environment = os.environ.copy()
+ environment["LC_ALL"] = "C"
+ result = subprocess.run( # noqa: S603
+ [
+ JBIG2DEC_BINARY,
+ "--embedded",
+ "--format", "png",
+ "--output", "-",
+ "-M", str(JBIG2_MAX_OUTPUT_LENGTH),
+ *paths
+ ],
+ capture_output=True,
+ env=environment,
+ )
+ if b"unrecognized option '--embedded'" in result.stderr or b"unrecognized option '-M'" in result.stderr:
+ raise DependencyError("jbig2dec>=0.19 is required.")
+ if b"FATAL ERROR failed to allocate image data buffer" in result.stderr:
+ raise LimitReachedError(
+ f"Memory limit reached while reading JBIG2 data:\n{result.stderr.decode('utf-8')}"
+ )
+ if result.stderr:
+ for line in result.stderr.decode("utf-8").splitlines():
+ logger_warning(line, __name__)
+ if result.returncode != 0:
+ raise PdfStreamError(f"Unable to decode JBIG2 data. Exit code: {result.returncode}")
+ return result.stdout
+
+ @staticmethod
+ def _is_binary_compatible() -> bool:
+ if not JBIG2DEC_BINARY: # pragma: no cover
+ return False
+ result = subprocess.run( # noqa: S603
+ [JBIG2DEC_BINARY, "--version"],
+ capture_output=True,
+ text=True,
+ )
+ version = result.stdout.split(" ", maxsplit=1)[1]
+
+ from ._utils import Version # noqa: PLC0415
+ return Version(version) >= Version("0.19")
+
+
+def decode_stream_data(stream: Any) -> bytes:
+ """
+ Decode the stream data based on the specified filters.
+
+ This function decodes the stream data using the filters provided in the
+ stream.
+
+ Args:
+ stream: The input stream object containing the data and filters.
+
+ Returns:
+ The decoded stream data.
+
+ Raises:
+ NotImplementedError: If an unsupported filter type is encountered.
+
+ """
+ filters = stream.get(SA.FILTER, ())
+ if isinstance(filters, IndirectObject):
+ filters = cast(ArrayObject, filters.get_object())
+ if not isinstance(filters, ArrayObject):
+ # We have a single filter instance
+ filters = (filters,)
+ decode_parms = stream.get(SA.DECODE_PARMS, ({},) * len(filters))
+ if not isinstance(decode_parms, (list, tuple)):
+ decode_parms = (decode_parms,)
+ data: bytes = stream._data
+ # If there is no data to decode, we should not try to decode it.
+ if not data:
+ return data
+ for filter_name, params in zip(filters, decode_parms):
+ if isinstance(params, NullObject):
+ params = {}
+ if filter_name in (FT.ASCII_HEX_DECODE, FTA.AHx):
+ data = ASCIIHexDecode.decode(data)
+ elif filter_name in (FT.ASCII_85_DECODE, FTA.A85):
+ data = ASCII85Decode.decode(data)
+ elif filter_name in (FT.LZW_DECODE, FTA.LZW):
+ data = LZWDecode.decode(data, params)
+ elif filter_name in (FT.FLATE_DECODE, FTA.FL):
+ data = FlateDecode.decode(data, params)
+ elif filter_name in (FT.RUN_LENGTH_DECODE, FTA.RL):
+ data = RunLengthDecode.decode(data)
+ elif filter_name == FT.CCITT_FAX_DECODE:
+ height = stream.get(IA.HEIGHT, ())
+ data = CCITTFaxDecode.decode(data, params, height)
+ elif filter_name == FT.DCT_DECODE:
+ data = DCTDecode.decode(data)
+ elif filter_name == FT.JPX_DECODE:
+ data = JPXDecode.decode(data)
+ elif filter_name == FT.JBIG2_DECODE:
+ data = JBIG2Decode.decode(data, params)
+ elif filter_name == "/Crypt":
+ if "/Name" in params or "/Type" in params:
+ raise NotImplementedError(
+ "/Crypt filter with /Name or /Type not supported yet"
+ )
+ else:
+ raise NotImplementedError(f"Unsupported filter {filter_name}")
+ return data
diff --git a/venv/lib/python3.12/site-packages/pypdf/generic/__init__.py b/venv/lib/python3.12/site-packages/pypdf/generic/__init__.py
new file mode 100644
index 0000000..bde1628
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/generic/__init__.py
@@ -0,0 +1,115 @@
+# Copyright (c) 2006, Mathieu Fenniak
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+
+"""Implementation of generic PDF objects (dictionary, number, string, ...)."""
+__author__ = "Mathieu Fenniak"
+__author_email__ = "biziqe@mathieu.fenniak.net"
+
+from ..constants import OutlineFontFlag
+from ._base import (
+ BooleanObject,
+ ByteStringObject,
+ FloatObject,
+ IndirectObject,
+ NameObject,
+ NullObject,
+ NumberObject,
+ PdfObject,
+ TextStringObject,
+ encode_pdfdocencoding,
+ is_null_or_none,
+)
+from ._data_structures import (
+ ArrayObject,
+ ContentStream,
+ DecodedStreamObject,
+ Destination,
+ DictionaryObject,
+ EncodedStreamObject,
+ Field,
+ StreamObject,
+ TreeObject,
+ read_object,
+)
+from ._files import EmbeddedFile
+from ._fit import Fit
+from ._link import DirectReferenceLink, NamedReferenceLink, ReferenceLink, extract_links
+from ._outline import OutlineItem
+from ._rectangle import RectangleObject
+from ._utils import (
+ create_string_object,
+ decode_pdfdocencoding,
+ hex_to_rgb,
+ read_hex_string_from_stream,
+ read_string_from_stream,
+)
+from ._viewerpref import ViewerPreferences
+
+PAGE_FIT = Fit.fit()
+
+
+__all__ = [
+ "PAGE_FIT",
+ "ArrayObject",
+ "BooleanObject",
+ "ByteStringObject",
+ "ContentStream",
+ "DecodedStreamObject",
+ "Destination",
+ "DictionaryObject",
+ "DirectReferenceLink",
+ "EmbeddedFile",
+ "EncodedStreamObject",
+ "Field",
+ "Fit",
+ "FloatObject",
+ "IndirectObject",
+ "NameObject",
+ "NamedReferenceLink",
+ "NullObject",
+ "NumberObject",
+ "OutlineFontFlag",
+ "OutlineItem",
+ "PdfObject",
+ "RectangleObject",
+ "ReferenceLink",
+ "StreamObject",
+ "TextStringObject",
+ "TreeObject",
+ "ViewerPreferences",
+ # Utility functions
+ "create_string_object",
+ "decode_pdfdocencoding",
+ "encode_pdfdocencoding",
+ "extract_links",
+ "hex_to_rgb",
+ "is_null_or_none",
+ "read_hex_string_from_stream",
+ # Data structures core functions
+ "read_object",
+ "read_string_from_stream",
+]
diff --git a/venv/lib/python3.12/site-packages/pypdf/generic/_appearance_stream.py b/venv/lib/python3.12/site-packages/pypdf/generic/_appearance_stream.py
new file mode 100644
index 0000000..1124d78
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/generic/_appearance_stream.py
@@ -0,0 +1,547 @@
+import re
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import Any, Optional, Union, cast
+
+from .._codecs import fill_from_encoding
+from .._codecs.core_fontmetrics import CORE_FONT_METRICS
+from .._font import Font
+from .._utils import logger_warning
+from ..constants import AnnotationDictionaryAttributes, BorderStyles, FieldDictionaryAttributes
+from ..generic import (
+ DecodedStreamObject,
+ DictionaryObject,
+ NameObject,
+ NumberObject,
+ RectangleObject,
+)
+from ..generic._base import ByteStringObject, TextStringObject, is_null_or_none
+
+DEFAULT_FONT_SIZE_IN_MULTILINE = 12
+
+
+@dataclass
+class BaseStreamConfig:
+ """A container representing the basic layout of an appearance stream."""
+ rectangle: Union[RectangleObject, tuple[float, float, float, float]] = (0.0, 0.0, 0.0, 0.0)
+ border_width: int = 1 # The width of the border in points
+ border_style: str = BorderStyles.SOLID
+
+
+class BaseStreamAppearance(DecodedStreamObject):
+ """A class representing the very base of an appearance stream, that is, a rectangle and a border."""
+
+ def __init__(self, layout: Optional[BaseStreamConfig] = None) -> None:
+ """
+ Takes the appearance stream layout as an argument.
+
+ Args:
+ layout: The basic layout parameters.
+ """
+ super().__init__()
+ self._layout = layout or BaseStreamConfig()
+ self[NameObject("/Type")] = NameObject("/XObject")
+ self[NameObject("/Subtype")] = NameObject("/Form")
+ self[NameObject("/BBox")] = RectangleObject(self._layout.rectangle)
+
+
+class TextAlignment(IntEnum):
+ """Defines the alignment options for text within a form field's appearance stream."""
+
+ LEFT = 0
+ CENTER = 1
+ RIGHT = 2
+
+
+class TextStreamAppearance(BaseStreamAppearance):
+ """
+ A class representing the appearance stream for a text-based form field.
+
+ This class generates the content stream (the `ap_stream_data`) that dictates
+ how text is rendered within a form field's bounding box. It handles properties
+ like font, font size, color, multiline text, and text selection highlighting.
+ """
+
+ def _scale_text(
+ self,
+ font: Font,
+ font_size: float,
+ leading_factor: float,
+ field_width: float,
+ field_height: float,
+ text: str,
+ min_font_size: float,
+ font_size_step: float = 0.2
+ ) -> tuple[list[tuple[float, str]], float]:
+ """
+ Takes a piece of text and scales it to field_width or field_height, given font_name
+ and font_size. Wraps text where necessary.
+
+ Args:
+ font: The font to be used.
+ font_size: The font size in points.
+ leading_factor: The line distance.
+ field_width: The width of the field in which to fit the text.
+ field_height: The height of the field in which to fit the text.
+ text: The text to fit with the field.
+ min_font_size: The minimum font size at which to scale the text.
+ font_size_step: The amount by which to decrement font size per step while scaling.
+
+ Returns:
+ The text in the form of list of tuples, each tuple containing the length of a line
+ and its contents, and the font_size for these lines and lengths.
+ """
+ orig_text = text
+ paragraphs = text.replace("\n", "\r").split("\r")
+ wrapped_lines = []
+ current_line_words: list[str] = []
+ current_line_width: float = 0
+ space_width = font.space_width * font_size / 1000
+ for paragraph in paragraphs:
+ if not paragraph.strip():
+ wrapped_lines.append((0.0, ""))
+ continue
+ words = paragraph.split(" ")
+ for i, word in enumerate(words):
+ word_width = font.text_width(word) * font_size / 1000
+ test_width = current_line_width + word_width + (space_width if i else 0)
+ if test_width > field_width and current_line_words:
+ wrapped_lines.append((current_line_width, " ".join(current_line_words)))
+ current_line_words = [word]
+ current_line_width = word_width
+ elif not current_line_words and word_width > field_width:
+ wrapped_lines.append((word_width, word))
+ current_line_words = []
+ current_line_width = 0
+ else:
+ if current_line_words:
+ current_line_width += space_width
+ current_line_words.append(word)
+ current_line_width += word_width
+ if current_line_words:
+ wrapped_lines.append((current_line_width, " ".join(current_line_words)))
+ current_line_words = []
+ current_line_width = 0
+ # Estimate total height.
+ estimated_total_height = font_size + (len(wrapped_lines) - 1) * leading_factor * font_size
+ if estimated_total_height > field_height:
+ # Text overflows height; Retry with smaller font size.
+ new_font_size = font_size - font_size_step
+ if new_font_size >= min_font_size:
+ return self._scale_text(
+ font,
+ new_font_size,
+ leading_factor,
+ field_width,
+ field_height,
+ orig_text,
+ min_font_size,
+ font_size_step
+ )
+ return wrapped_lines, round(font_size, 1)
+
+ def _generate_appearance_stream_data(
+ self,
+ text: str,
+ selection: Union[list[str], None],
+ font: Font,
+ font_glyph_byte_map: Optional[dict[str, bytes]] = None,
+ font_name: str = "/Helv",
+ font_size: float = 0.0,
+ font_color: str = "0 g",
+ is_multiline: bool = False,
+ alignment: TextAlignment = TextAlignment.LEFT,
+ is_comb: bool = False,
+ max_length: Optional[int] = None
+ ) -> bytes:
+ """
+ Generates the raw bytes of the PDF appearance stream for a text field.
+
+ This private method assembles the PDF content stream operators to draw
+ the provided text within the specified rectangle. It handles text positioning,
+ font application, color, and special formatting like selected text.
+
+ Args:
+ text: The text to be rendered in the form field.
+ selection: An optional list of strings that should be highlighted as selected.
+ font: The font to use.
+ font_glyph_byte_map: An optional dictionary mapping characters to their
+ byte representation for glyph encoding.
+ font_name: The name of the font resource to use (e.g., "/Helv").
+ font_size: The font size. If 0, it is automatically calculated
+ based on whether the field is multiline or not.
+ font_color: The color to apply to the font, represented as a PDF
+ graphics state string (e.g., "0 g" for black).
+ is_multiline: A boolean indicating if the text field is multiline.
+ alignment: Text alignment, can be TextAlignment.LEFT, .RIGHT, or .CENTER.
+ is_comb: Boolean that designates fixed-length fields, where every character
+ fills one "cell", such as in a postcode.
+ max_length: Used if is_comb is set. The maximum number of characters for a fixed-
+ length field.
+
+ Returns:
+ A byte string containing the PDF content stream data.
+
+ """
+ rectangle = self._layout.rectangle
+ font_glyph_byte_map = font_glyph_byte_map or {}
+ if isinstance(rectangle, tuple):
+ rectangle = RectangleObject(rectangle)
+ leading_factor = (font.font_descriptor.bbox[3] - font.font_descriptor.bbox[1]) / 1000.0
+
+ # Set margins based on border width and style, but never less than 1 point
+ factor = 2 if self._layout.border_style in {"/B", "/I"} else 1
+ margin = max(self._layout.border_width * factor, 1)
+ field_height = rectangle.height - 2 * margin
+ field_width = rectangle.width - 4 * margin
+
+ # If font_size is 0, apply the logic for multiline or large-as-possible font
+ if font_size == 0:
+ min_font_size = 4.0 # The mininum font size
+ if selection: # Don't wrap text when dealing with a /Ch field, in order to prevent problems
+ is_multiline = False # with matching "selection" with "line" later on.
+ if is_multiline:
+ font_size = DEFAULT_FONT_SIZE_IN_MULTILINE
+ lines, font_size = self._scale_text(
+ font,
+ font_size,
+ leading_factor,
+ field_width,
+ field_height,
+ text,
+ min_font_size
+ )
+ else:
+ max_vertical_size = field_height / leading_factor
+ text_width_unscaled = font.text_width(text) / 1000
+ max_horizontal_size = field_width / (text_width_unscaled or 1)
+ font_size = round(max(min(max_vertical_size, max_horizontal_size), min_font_size), 1)
+ lines = [(text_width_unscaled * font_size, text)]
+ elif is_comb:
+ if max_length and len(text) > max_length:
+ logger_warning (
+ f"Length of text {text} exceeds maximum length ({max_length}) of field, input truncated.",
+ __name__
+ )
+ # We act as if each character is one line, because we draw it separately later on
+ lines = [(
+ font.text_width(char) * font_size / 1000,
+ char
+ ) for index, char in enumerate(text) if index < (max_length or len(text))]
+ else:
+ lines = [(
+ font.text_width(line) * font_size / 1000,
+ line
+ ) for line in text.replace("\n", "\r").split("\r")]
+
+ # Set the vertical offset
+ if is_multiline:
+ y_offset = rectangle.height + margin - font.font_descriptor.bbox[3] * font_size / 1000.0
+ else:
+ y_offset = margin + ((field_height - font.font_descriptor.ascent * font_size / 1000) / 2)
+ default_appearance = f"{font_name} {font_size} Tf {font_color}"
+
+ ap_stream = (
+ f"q\n/Tx BMC \nq\n{2 * margin} {margin} {field_width} {field_height} "
+ f"re\nW\nBT\n{default_appearance}\n"
+ ).encode()
+ current_x_pos: float = 0 # Initial virtual position within the text object.
+
+ for line_number, (line_width, line) in enumerate(lines):
+ if selection and line in selection:
+ # Might be improved, but cannot find how to get fill working => replaced with lined box
+ ap_stream += (
+ f"1 {y_offset - (line_number * font_size * leading_factor) - 1} "
+ f"{rectangle.width - 2} {font_size + 2} re\n"
+ f"0.5 0.5 0.5 rg s\n{default_appearance}\n"
+ ).encode()
+
+ # Calculate the desired absolute starting X for the current line
+ desired_abs_x_start: float = 0
+ if is_comb and max_length:
+ # Calculate the width of a cell for one character
+ cell_width = rectangle.width / max_length
+ # Space from the left edge of the cell to the character's baseline start
+ # line_width here is the *actual* character width in points for the single character 'line'
+ centering_offset_in_cell = (cell_width - line_width) / 2
+ # Absolute start X = (Cell Index, i.e., line_number * Cell Width) + Centering Offset
+ desired_abs_x_start = (line_number * cell_width) + centering_offset_in_cell
+ elif alignment == TextAlignment.RIGHT:
+ desired_abs_x_start = rectangle.width - margin * 2 - line_width
+ elif alignment == TextAlignment.CENTER:
+ desired_abs_x_start = (rectangle.width - line_width) / 2
+ else: # Left aligned; default
+ desired_abs_x_start = margin * 2
+ # Calculate x_rel_offset: how much to move from the current_x_pos
+ # to reach the desired_abs_x_start.
+ x_rel_offset = desired_abs_x_start - current_x_pos
+
+ # Y-offset:
+ y_rel_offset: float = 0
+ if line_number == 0:
+ y_rel_offset = y_offset # Initial vertical position
+ elif is_comb:
+ y_rel_offset = 0.0 # DO NOT move vertically for subsequent characters
+ else:
+ y_rel_offset = - font_size * leading_factor # Move down by line height
+
+ # Td is a relative translation (Tx and Ty).
+ # It updates the current text position.
+ ap_stream += f"{x_rel_offset} {y_rel_offset} Td\n".encode()
+ # Update current_x_pos based on the Td operation for the next iteration.
+ # This is the X position where the *current line* will start.
+ current_x_pos = desired_abs_x_start
+
+ encoded_line: list[bytes] = [
+ font_glyph_byte_map.get(c, c.encode("utf-16-be")) for c in line
+ ]
+ if any(len(c) >= 2 for c in encoded_line):
+ ap_stream += b"<" + (b"".join(encoded_line)).hex().encode() + b"> Tj\n"
+ else:
+ ap_stream += b"(" + b"".join(encoded_line) + b") Tj\n"
+ ap_stream += b"ET\nQ\nEMC\nQ\n"
+ return ap_stream
+
+ def __init__(
+ self,
+ layout: Optional[BaseStreamConfig] = None,
+ text: str = "",
+ selection: Optional[list[str]] = None,
+ font_resource: Optional[DictionaryObject] = None,
+ font_name: str = "/Helv",
+ font_size: float = 0.0,
+ font_color: str = "0 g",
+ is_multiline: bool = False,
+ alignment: TextAlignment = TextAlignment.LEFT,
+ is_comb: bool = False,
+ max_length: Optional[int] = None
+ ) -> None:
+ """
+ Initializes a TextStreamAppearance object.
+
+ This constructor creates a new PDF stream object configured as an XObject
+ of subtype Form. It uses the `_appearance_stream_data` method to generate
+ the content for the stream.
+
+ Args:
+ layout: The basic layout parameters.
+ text: The text to be rendered in the form field.
+ selection: An optional list of strings that should be highlighted as selected.
+ font_resource: An optional variable that represents a PDF font dictionary.
+ font_name: The name of the font resource, e.g., "/Helv".
+ font_size: The font size. If 0, it's auto-calculated.
+ font_color: The font color string.
+ is_multiline: A boolean indicating if the text field is multiline.
+ alignment: Text alignment, can be TextAlignment.LEFT, .RIGHT, or .CENTER.
+ is_comb: Boolean that designates fixed-length fields, where every character
+ fills one "cell", such as in a postcode.
+ max_length: Used if is_comb is set. The maximum number of characters for a fixed-
+ length field.
+
+ """
+ super().__init__(layout)
+
+ # If a font resource was added, get the font character map
+ if font_resource:
+ font_resource = cast(DictionaryObject, font_resource.get_object())
+ font = Font.from_font_resource(font_resource)
+ else:
+ logger_warning(f"Font dictionary for {font_name} not found; defaulting to Helvetica.", __name__)
+ font_name = "/Helv"
+ font_resource = DictionaryObject({
+ NameObject("/Subtype"): NameObject("/Type1"),
+ NameObject("/Name"): NameObject("/Helv"),
+ NameObject("/Type"): NameObject("/Font"),
+ NameObject("/BaseFont"): NameObject("/Helvetica"),
+ NameObject("/Encoding"): NameObject("/WinAnsiEncoding")
+ })
+ font_descriptor = CORE_FONT_METRICS["Helvetica"]
+ font_descriptor.character_widths["default"] = 2 * font_descriptor.character_widths[" "]
+ font = Font(
+ name="Helvetica",
+ character_map={},
+ encoding=dict(zip(range(256), fill_from_encoding("cp1252"))), # WinAnsiEncoding
+ sub_type="Type1",
+ font_descriptor = font_descriptor,
+ character_widths = font_descriptor.character_widths
+ )
+
+ font_glyph_byte_map: dict[str, bytes]
+ if isinstance(font.encoding, str):
+ font_glyph_byte_map = {
+ v: k.encode(font.encoding) for k, v in font.character_map.items()
+ }
+ else:
+ font_glyph_byte_map = {v: bytes((k,)) for k, v in font.encoding.items()}
+ font_encoding_rev = {v: bytes((k,)) for k, v in font.encoding.items()}
+ for key, value in font.character_map.items():
+ font_glyph_byte_map[value] = font_encoding_rev.get(key, key)
+
+ ap_stream_data = self._generate_appearance_stream_data(
+ text,
+ selection,
+ font,
+ font_glyph_byte_map,
+ font_name=font_name,
+ font_size=font_size,
+ font_color=font_color,
+ is_multiline=is_multiline,
+ alignment=alignment,
+ is_comb=is_comb,
+ max_length=max_length
+ )
+
+ self.set_data(ByteStringObject(ap_stream_data))
+ self[NameObject("/Length")] = NumberObject(len(ap_stream_data))
+ # Update Resources with font information
+ self[NameObject("/Resources")] = DictionaryObject({
+ NameObject("/Font"): DictionaryObject({
+ NameObject(font_name): getattr(font_resource, "indirect_reference", font_resource)
+ })
+ })
+
+ @classmethod
+ def from_text_annotation(
+ cls,
+ acro_form: DictionaryObject, # _root_object[CatalogDictionary.ACRO_FORM])
+ field: DictionaryObject,
+ annotation: DictionaryObject,
+ user_font_name: str = "",
+ user_font_size: float = -1,
+ ) -> "TextStreamAppearance":
+ """
+ Creates a TextStreamAppearance object from a text field annotation.
+
+ This class method is a factory for creating a `TextStreamAppearance`
+ instance by extracting all necessary information (bounding box, font,
+ text content, etc.) from the PDF field and annotation dictionaries.
+ It respects inheritance for properties like default appearance (`/DA`).
+
+ Args:
+ acro_form: The root AcroForm dictionary from the PDF catalog.
+ field: The field dictionary object.
+ annotation: The widget annotation dictionary object associated with the field.
+ user_font_name: An optional user-provided font name to override the
+ default. Defaults to an empty string.
+ user_font_size: An optional user-provided font size to override the
+ default. A value of -1 indicates no override.
+
+ Returns:
+ A new `TextStreamAppearance` instance configured for the given field.
+
+ """
+ # Calculate rectangle dimensions
+ _rectangle = cast(RectangleObject, annotation[AnnotationDictionaryAttributes.Rect])
+ rectangle = RectangleObject((0, 0, abs(_rectangle[2] - _rectangle[0]), abs(_rectangle[3] - _rectangle[1])))
+
+ # Get default appearance dictionary from annotation
+ default_appearance = annotation.get_inherited(
+ AnnotationDictionaryAttributes.DA,
+ acro_form.get(AnnotationDictionaryAttributes.DA, None),
+ )
+ if not default_appearance:
+ # Create a default appearance if none was found in the annotation
+ default_appearance = TextStringObject("/Helv 0 Tf 0 g")
+ else:
+ default_appearance = default_appearance.get_object()
+
+ # Derive font name, size and color from the default appearance. Also set
+ # user-provided font name and font size in the default appearance, if given.
+ # For a font name, this presumes that we can find an associated font resource
+ # dictionary. Uses the variable font_properties as an intermediate.
+ # As per the PDF spec:
+ # "At a minimum, the string [that is, default_appearance] shall include a Tf (text
+ # font) operator along with its two operands, font and size" (Section 12.7.4.3
+ # "Variable text" of the PDF 2.0 specification).
+ font_properties = [prop for prop in re.split(r"\s", default_appearance) if prop]
+ font_name = font_properties.pop(font_properties.index("Tf") - 2)
+ font_size = float(font_properties.pop(font_properties.index("Tf") - 1))
+ font_properties.remove("Tf")
+ font_color = " ".join(font_properties)
+ # Determine the font name to use, prioritizing the user's input
+ if user_font_name:
+ font_name = user_font_name
+ # Determine the font size to use, prioritizing the user's input
+ if user_font_size > 0:
+ font_size = user_font_size
+
+ # Try to find a resource dictionary for the font
+ document_resources: Any = cast(
+ DictionaryObject,
+ cast(
+ DictionaryObject,
+ annotation.get_inherited(
+ "/DR",
+ acro_form.get("/DR", DictionaryObject()),
+ ),
+ ).get_object(),
+ )
+ document_font_resources = document_resources.get("/Font", DictionaryObject()).get_object()
+ # CORE_FONT_METRICS is the dict with Standard font metrics
+ if font_name not in document_font_resources and font_name.removeprefix("/") not in CORE_FONT_METRICS:
+ # ...or AcroForm dictionary
+ document_resources = cast(
+ dict[Any, Any],
+ acro_form.get("/DR", {}),
+ )
+ document_font_resources = document_resources.get_object().get("/Font", DictionaryObject()).get_object()
+ font_resource = document_font_resources.get(font_name, None)
+ if not is_null_or_none(font_resource):
+ font_resource = cast(DictionaryObject, font_resource.get_object())
+
+ # Retrieve field text and selected values
+ field_flags = field.get(FieldDictionaryAttributes.Ff, 0)
+ if (
+ field.get(FieldDictionaryAttributes.FT, "/Tx") == "/Ch" and
+ field_flags & FieldDictionaryAttributes.FfBits.Combo == 0
+ ):
+ text = "\n".join(annotation.get_inherited(FieldDictionaryAttributes.Opt, []))
+ selection = field.get("/V", [])
+ if not isinstance(selection, list):
+ selection = [selection]
+ else: # /Tx
+ text = field.get("/V", "")
+ selection = []
+
+ # Escape parentheses (PDF 1.7 reference, table 3.2, Literal Strings)
+ text = text.replace("\\", "\\\\").replace("(", r"\(").replace(")", r"\)")
+
+ # Retrieve formatting information
+ is_comb = False
+ max_length = None
+ if field_flags & FieldDictionaryAttributes.FfBits.Comb:
+ is_comb = True
+ max_length = annotation.get("/MaxLen")
+ is_multiline = False
+ if field_flags & FieldDictionaryAttributes.FfBits.Multiline:
+ is_multiline = True
+ alignment = field.get("/Q", TextAlignment.LEFT)
+ border_width = 1
+ border_style = BorderStyles.SOLID
+ if "/BS" in field:
+ border_width = cast(DictionaryObject, field["/BS"]).get("/W", border_width)
+ border_style = cast(DictionaryObject, field["/BS"]).get("/S", border_style)
+
+ # Create the TextStreamAppearance instance
+ layout = BaseStreamConfig(rectangle=rectangle, border_width=border_width, border_style=border_style)
+ new_appearance_stream = cls(
+ layout,
+ text,
+ selection,
+ font_resource,
+ font_name=font_name,
+ font_size=font_size,
+ font_color=font_color,
+ is_multiline=is_multiline,
+ alignment=alignment,
+ is_comb=is_comb,
+ max_length=max_length
+ )
+ if AnnotationDictionaryAttributes.AP in annotation:
+ for key, value in (
+ cast(DictionaryObject, annotation[AnnotationDictionaryAttributes.AP]).get("/N", {}).items()
+ ):
+ if key not in {"/BBox", "/Length", "/Subtype", "/Type", "/Filter"}:
+ new_appearance_stream[key] = value
+
+ return new_appearance_stream
diff --git a/venv/lib/python3.12/site-packages/pypdf/generic/_base.py b/venv/lib/python3.12/site-packages/pypdf/generic/_base.py
new file mode 100644
index 0000000..ab7ae1b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/generic/_base.py
@@ -0,0 +1,937 @@
+# Copyright (c) 2006, Mathieu Fenniak
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+import binascii
+import codecs
+import hashlib
+import re
+import sys
+from binascii import unhexlify
+from collections.abc import Sequence
+from math import log10
+from struct import iter_unpack
+from typing import Any, Callable, ClassVar, Optional, Union, cast
+
+if sys.version_info[:2] >= (3, 10):
+ from typing import TypeGuard
+else:
+ from typing_extensions import TypeGuard # PEP 647
+
+from .._codecs import _pdfdoc_encoding_rev
+from .._protocols import PdfObjectProtocol, PdfWriterProtocol
+from .._utils import (
+ StreamType,
+ classproperty,
+ deprecation_no_replacement,
+ deprecation_with_replacement,
+ logger_warning,
+ read_non_whitespace,
+ read_until_regex,
+)
+from ..errors import STREAM_TRUNCATED_PREMATURELY, PdfReadError, PdfStreamError
+
+__author__ = "Mathieu Fenniak"
+__author_email__ = "biziqe@mathieu.fenniak.net"
+
+
+class PdfObject(PdfObjectProtocol):
+ # function for calculating a hash value
+ hash_func: Callable[..., "hashlib._Hash"] = hashlib.sha1
+ indirect_reference: Optional["IndirectObject"]
+
+ def hash_bin(self) -> int:
+ """
+ Used to detect modified object.
+
+ Returns:
+ Hash considering type and value.
+
+ """
+ raise NotImplementedError(
+ f"{self.__class__.__name__} does not implement .hash_bin() so far"
+ )
+
+ def hash_value_data(self) -> bytes:
+ return f"{self}".encode()
+
+ def hash_value(self) -> bytes:
+ return (
+ f"{self.__class__.__name__}:"
+ f"{self.hash_func(self.hash_value_data()).hexdigest()}"
+ ).encode()
+
+ def replicate(
+ self,
+ pdf_dest: PdfWriterProtocol,
+ ) -> "PdfObject":
+ """
+ Clone object into pdf_dest (PdfWriterProtocol which is an interface for PdfWriter)
+ without ensuring links. This is used in clone_document_from_root with incremental = True.
+
+ Args:
+ pdf_dest: Target to clone to.
+
+ Returns:
+ The cloned PdfObject
+
+ """
+ return self.clone(pdf_dest)
+
+ def clone(
+ self,
+ pdf_dest: PdfWriterProtocol,
+ force_duplicate: bool = False,
+ ignore_fields: Optional[Sequence[Union[str, int]]] = (),
+ ) -> "PdfObject":
+ """
+ Clone object into pdf_dest (PdfWriterProtocol which is an interface for PdfWriter).
+
+ By default, this method will call ``_reference_clone`` (see ``_reference``).
+
+
+ Args:
+ pdf_dest: Target to clone to.
+ force_duplicate: By default, if the object has already been cloned and referenced,
+ the copy will be returned; when ``True``, a new copy will be created.
+ (Default value = ``False``)
+ ignore_fields: List/tuple of field names (for dictionaries) that will be ignored
+ during cloning (applies to children duplication as well). If fields are to be
+ considered for a limited number of levels, you have to add it as integer, for
+ example ``[1,"/B","/TOTO"]`` means that ``"/B"`` will be ignored at the first
+ level only but ``"/TOTO"`` on all levels.
+
+ Returns:
+ The cloned PdfObject
+
+ """
+ raise NotImplementedError(
+ f"{self.__class__.__name__} does not implement .clone so far"
+ )
+
+ def _reference_clone(
+ self, clone: Any, pdf_dest: PdfWriterProtocol, force_duplicate: bool = False
+ ) -> PdfObjectProtocol:
+ """
+ Reference the object within the _objects of pdf_dest only if
+ indirect_reference attribute exists (which means the objects was
+ already identified in xref/xobjstm) if object has been already
+ referenced do nothing.
+
+ Args:
+ clone:
+ pdf_dest:
+
+ Returns:
+ The clone
+
+ """
+ try:
+ if not force_duplicate and clone.indirect_reference.pdf == pdf_dest:
+ return clone
+ except Exception:
+ pass
+ # if hasattr(clone, "indirect_reference"):
+ try:
+ ind = self.indirect_reference
+ except AttributeError:
+ return clone
+ if (
+ pdf_dest.incremental
+ and ind is not None
+ and ind.pdf == pdf_dest._reader
+ and ind.idnum <= len(pdf_dest._objects)
+ ):
+ i = ind.idnum
+ else:
+ i = len(pdf_dest._objects) + 1
+ if ind is not None:
+ if id(ind.pdf) not in pdf_dest._id_translated:
+ pdf_dest._id_translated[id(ind.pdf)] = {}
+ pdf_dest._id_translated[id(ind.pdf)]["PreventGC"] = ind.pdf # type: ignore[index]
+ if (
+ not force_duplicate
+ and ind.idnum in pdf_dest._id_translated[id(ind.pdf)]
+ ):
+ obj = pdf_dest.get_object(
+ pdf_dest._id_translated[id(ind.pdf)][ind.idnum]
+ )
+ assert obj is not None
+ return obj
+ pdf_dest._id_translated[id(ind.pdf)][ind.idnum] = i
+ try:
+ pdf_dest._objects[i - 1] = clone
+ except IndexError:
+ pdf_dest._objects.append(clone)
+ i = len(pdf_dest._objects)
+ clone.indirect_reference = IndirectObject(i, 0, pdf_dest)
+ return clone
+
+ def get_object(self) -> Optional["PdfObject"]:
+ """Resolve indirect references."""
+ return self
+
+ def write_to_stream(
+ self, stream: StreamType, encryption_key: Union[None, str, bytes] = None
+ ) -> None:
+ raise NotImplementedError
+
+
+class NullObject(PdfObject):
+ def clone(
+ self,
+ pdf_dest: PdfWriterProtocol,
+ force_duplicate: bool = False,
+ ignore_fields: Optional[Sequence[Union[str, int]]] = (),
+ ) -> "NullObject":
+ """Clone object into pdf_dest."""
+ return cast(
+ "NullObject", self._reference_clone(NullObject(), pdf_dest, force_duplicate)
+ )
+
+ def hash_bin(self) -> int:
+ """
+ Used to detect modified object.
+
+ Returns:
+ Hash considering type and value.
+
+ """
+ return hash((self.__class__,))
+
+ def write_to_stream(
+ self, stream: StreamType, encryption_key: Union[None, str, bytes] = None
+ ) -> None:
+ if encryption_key is not None: # deprecated
+ deprecation_no_replacement(
+ "the encryption_key parameter of write_to_stream", "5.0.0"
+ )
+ stream.write(b"null")
+
+ @staticmethod
+ def read_from_stream(stream: StreamType) -> "NullObject":
+ nulltxt = stream.read(4)
+ if nulltxt != b"null":
+ raise PdfReadError("Could not read Null object")
+ return NullObject()
+
+ def __repr__(self) -> str:
+ return "NullObject"
+
+ def __eq__(self, other: object) -> bool:
+ return isinstance(other, NullObject)
+
+ def __hash__(self) -> int:
+ return self.hash_bin()
+
+
+class BooleanObject(PdfObject):
+ def __init__(self, value: Any) -> None:
+ self.value = value
+
+ def clone(
+ self,
+ pdf_dest: PdfWriterProtocol,
+ force_duplicate: bool = False,
+ ignore_fields: Optional[Sequence[Union[str, int]]] = (),
+ ) -> "BooleanObject":
+ """Clone object into pdf_dest."""
+ return cast(
+ "BooleanObject",
+ self._reference_clone(BooleanObject(self.value), pdf_dest, force_duplicate),
+ )
+
+ def hash_bin(self) -> int:
+ """
+ Used to detect modified object.
+
+ Returns:
+ Hash considering type and value.
+
+ """
+ return hash((self.__class__, self.value))
+
+ def __eq__(self, o: object, /) -> bool:
+ if isinstance(o, BooleanObject):
+ return self.value == o.value
+ if isinstance(o, bool):
+ return self.value == o
+ return False
+
+ def __hash__(self) -> int:
+ return self.hash_bin()
+
+ def __repr__(self) -> str:
+ return "True" if self.value else "False"
+
+ def write_to_stream(
+ self, stream: StreamType, encryption_key: Union[None, str, bytes] = None
+ ) -> None:
+ if encryption_key is not None: # deprecated
+ deprecation_no_replacement(
+ "the encryption_key parameter of write_to_stream", "5.0.0"
+ )
+ if self.value:
+ stream.write(b"true")
+ else:
+ stream.write(b"false")
+
+ @staticmethod
+ def read_from_stream(stream: StreamType) -> "BooleanObject":
+ word = stream.read(4)
+ if word == b"true":
+ return BooleanObject(True)
+ if word == b"fals":
+ stream.read(1)
+ return BooleanObject(False)
+ raise PdfReadError("Could not read Boolean object")
+
+
+class IndirectObject(PdfObject):
+ def __init__(self, idnum: int, generation: int, pdf: Any) -> None: # PdfReader
+ self.idnum = idnum
+ self.generation = generation
+ self.pdf = pdf
+
+ def __hash__(self) -> int:
+ return hash((self.idnum, self.generation, id(self.pdf)))
+
+ def hash_bin(self) -> int:
+ """
+ Used to detect modified object.
+
+ Returns:
+ Hash considering type and value.
+
+ """
+ return hash((self.__class__, self.idnum, self.generation, id(self.pdf)))
+
+ def replicate(
+ self,
+ pdf_dest: PdfWriterProtocol,
+ ) -> "PdfObject":
+ return IndirectObject(self.idnum, self.generation, pdf_dest)
+
+ def clone(
+ self,
+ pdf_dest: PdfWriterProtocol,
+ force_duplicate: bool = False,
+ ignore_fields: Optional[Sequence[Union[str, int]]] = (),
+ ) -> "IndirectObject":
+ """Clone object into pdf_dest."""
+ if self.pdf == pdf_dest and not force_duplicate:
+ # Already duplicated and no extra duplication required
+ return self
+ if id(self.pdf) not in pdf_dest._id_translated:
+ pdf_dest._id_translated[id(self.pdf)] = {}
+ pdf_dest._id_translated[id(self.pdf)]["PreventGC"] = self.pdf # type: ignore[index]
+
+ if self.idnum in pdf_dest._id_translated[id(self.pdf)]:
+ dup = pdf_dest.get_object(pdf_dest._id_translated[id(self.pdf)][self.idnum])
+ if force_duplicate:
+ assert dup is not None
+ assert dup.indirect_reference is not None
+ idref = dup.indirect_reference
+ return IndirectObject(idref.idnum, idref.generation, idref.pdf)
+ else:
+ obj = self.get_object()
+ # case observed : a pointed object can not be found
+ if obj is None:
+ # this normally
+ obj = NullObject()
+ assert isinstance(self, (IndirectObject,))
+ obj.indirect_reference = self
+ dup = pdf_dest._add_object(
+ obj.clone(pdf_dest, force_duplicate, ignore_fields)
+ )
+ assert dup is not None, "mypy"
+ assert dup.indirect_reference is not None, "mypy"
+ return dup.indirect_reference
+
+ @property
+ def indirect_reference(self) -> "IndirectObject": # type: ignore[override]
+ return self
+
+ def get_object(self) -> Optional["PdfObject"]:
+ return self.pdf.get_object(self)
+
+ def __deepcopy__(self, memo: Any) -> "IndirectObject":
+ return IndirectObject(self.idnum, self.generation, self.pdf)
+
+ def _get_object_with_check(self) -> Optional["PdfObject"]:
+ o = self.get_object()
+ # the check is done here to not slow down get_object()
+ if isinstance(o, IndirectObject):
+ raise PdfStreamError(
+ f"{self.__repr__()} references an IndirectObject {o.__repr__()}"
+ )
+ return o
+
+ def __getattr__(self, name: str) -> Any:
+ # Attribute not found in object: look in pointed object
+ try:
+ return getattr(self._get_object_with_check(), name)
+ except AttributeError:
+ raise AttributeError(
+ f"No attribute {name} found in IndirectObject or pointed object"
+ )
+
+ def __getitem__(self, key: Any) -> Any:
+ # items should be extracted from pointed Object
+ return self._get_object_with_check()[key] # type: ignore
+
+ def __contains__(self, key: Any) -> bool:
+ return key in self._get_object_with_check() # type: ignore
+
+ def __iter__(self) -> Any:
+ return self._get_object_with_check().__iter__() # type: ignore
+
+ def __float__(self) -> str:
+ # in this case we are looking for the pointed data
+ return self.get_object().__float__() # type: ignore
+
+ def __int__(self) -> int:
+ # in this case we are looking for the pointed data
+ return self.get_object().__int__() # type: ignore
+
+ def __str__(self) -> str:
+ # in this case we are looking for the pointed data
+ return self.get_object().__str__()
+
+ def __repr__(self) -> str:
+ return f"IndirectObject({self.idnum!r}, {self.generation!r}, {id(self.pdf)})"
+
+ def __eq__(self, other: object) -> bool:
+ return (
+ other is not None
+ and isinstance(other, IndirectObject)
+ and self.idnum == other.idnum
+ and self.generation == other.generation
+ and self.pdf is other.pdf
+ )
+
+ def __ne__(self, other: object) -> bool:
+ return not self.__eq__(other)
+
+ def write_to_stream(
+ self, stream: StreamType, encryption_key: Union[None, str, bytes] = None
+ ) -> None:
+ if encryption_key is not None: # deprecated
+ deprecation_no_replacement(
+ "the encryption_key parameter of write_to_stream", "5.0.0"
+ )
+ stream.write(f"{self.idnum} {self.generation} R".encode())
+
+ @staticmethod
+ def read_from_stream(stream: StreamType, pdf: Any) -> "IndirectObject": # PdfReader
+ idnum = b""
+ while True:
+ tok = stream.read(1)
+ if not tok:
+ raise PdfStreamError(STREAM_TRUNCATED_PREMATURELY)
+ if tok.isspace():
+ break
+ idnum += tok
+ generation = b""
+ while True:
+ tok = stream.read(1)
+ if not tok:
+ raise PdfStreamError(STREAM_TRUNCATED_PREMATURELY)
+ if tok.isspace():
+ if not generation:
+ continue
+ break
+ generation += tok
+ r = read_non_whitespace(stream)
+ if r != b"R":
+ raise PdfReadError(
+ f"Error reading indirect object reference at byte {hex(stream.tell())}"
+ )
+ return IndirectObject(int(idnum), int(generation), pdf)
+
+
+FLOAT_WRITE_PRECISION = 8 # shall be min 5 digits max, allow user adj
+
+
+class FloatObject(float, PdfObject):
+ def __new__(
+ cls, value: Any = "0.0", context: Optional[Any] = None
+ ) -> "FloatObject":
+ try:
+ value = float(value)
+ return float.__new__(cls, value)
+ except Exception as e:
+ # If this isn't a valid decimal (happens in malformed PDFs)
+ # fallback to 0
+ logger_warning(
+ f"{e} : FloatObject ({value}) invalid; use 0.0 instead", __name__
+ )
+ return float.__new__(cls, 0.0)
+
+ def clone(
+ self,
+ pdf_dest: Any,
+ force_duplicate: bool = False,
+ ignore_fields: Optional[Sequence[Union[str, int]]] = (),
+ ) -> "FloatObject":
+ """Clone object into pdf_dest."""
+ return cast(
+ "FloatObject",
+ self._reference_clone(FloatObject(self), pdf_dest, force_duplicate),
+ )
+
+ def hash_bin(self) -> int:
+ """
+ Used to detect modified object.
+
+ Returns:
+ Hash considering type and value.
+
+ """
+ return hash((self.__class__, self.as_numeric))
+
+ def myrepr(self) -> str:
+ if self == 0:
+ return "0.0"
+ nb = FLOAT_WRITE_PRECISION - int(log10(abs(self)))
+ return f"{self:.{max(1, nb)}f}".rstrip("0").rstrip(".")
+
+ def __repr__(self) -> str:
+ return self.myrepr() # repr(float(self))
+
+ def as_numeric(self) -> float:
+ return float(self)
+
+ def write_to_stream(
+ self, stream: StreamType, encryption_key: Union[None, str, bytes] = None
+ ) -> None:
+ if encryption_key is not None: # deprecated
+ deprecation_no_replacement(
+ "the encryption_key parameter of write_to_stream", "5.0.0"
+ )
+ stream.write(self.myrepr().encode("utf8"))
+
+
+class NumberObject(int, PdfObject):
+ NumberPattern = re.compile(b"[^+-.0-9]")
+
+ def __new__(cls, value: Any) -> "NumberObject":
+ try:
+ return int.__new__(cls, int(value))
+ except ValueError:
+ logger_warning(f"NumberObject({value}) invalid; use 0 instead", __name__)
+ return int.__new__(cls, 0)
+
+ def clone(
+ self,
+ pdf_dest: Any,
+ force_duplicate: bool = False,
+ ignore_fields: Optional[Sequence[Union[str, int]]] = (),
+ ) -> "NumberObject":
+ """Clone object into pdf_dest."""
+ return cast(
+ "NumberObject",
+ self._reference_clone(NumberObject(self), pdf_dest, force_duplicate),
+ )
+
+ def hash_bin(self) -> int:
+ """
+ Used to detect modified object.
+
+ Returns:
+ Hash considering type and value.
+
+ """
+ return hash((self.__class__, self.as_numeric()))
+
+ def as_numeric(self) -> int:
+ return int(repr(self).encode("utf8"))
+
+ def write_to_stream(
+ self, stream: StreamType, encryption_key: Union[None, str, bytes] = None
+ ) -> None:
+ if encryption_key is not None: # deprecated
+ deprecation_no_replacement(
+ "the encryption_key parameter of write_to_stream", "5.0.0"
+ )
+ stream.write(repr(self).encode("utf8"))
+
+ @staticmethod
+ def read_from_stream(stream: StreamType) -> Union["NumberObject", "FloatObject"]:
+ num = read_until_regex(stream, NumberObject.NumberPattern)
+ if b"." in num:
+ return FloatObject(num)
+ return NumberObject(num)
+
+
+class ByteStringObject(bytes, PdfObject):
+ """
+ Represents a string object where the text encoding could not be determined.
+
+ This occurs quite often, as the PDF spec doesn't provide an alternate way to
+ represent strings -- for example, the encryption data stored in files (like
+ /O) is clearly not text, but is still stored in a "String" object.
+ """
+
+ def clone(
+ self,
+ pdf_dest: Any,
+ force_duplicate: bool = False,
+ ignore_fields: Optional[Sequence[Union[str, int]]] = (),
+ ) -> "ByteStringObject":
+ """Clone object into pdf_dest."""
+ return cast(
+ "ByteStringObject",
+ self._reference_clone(
+ ByteStringObject(bytes(self)), pdf_dest, force_duplicate
+ ),
+ )
+
+ def hash_bin(self) -> int:
+ """
+ Used to detect modified object.
+
+ Returns:
+ Hash considering type and value.
+
+ """
+ return hash((self.__class__, bytes(self)))
+
+ @property
+ def original_bytes(self) -> bytes:
+ """For compatibility with TextStringObject.original_bytes."""
+ return self
+
+ def write_to_stream(
+ self, stream: StreamType, encryption_key: Union[None, str, bytes] = None
+ ) -> None:
+ if encryption_key is not None: # deprecated
+ deprecation_no_replacement(
+ "the encryption_key parameter of write_to_stream", "5.0.0"
+ )
+ stream.write(b"<")
+ stream.write(binascii.hexlify(self))
+ stream.write(b">")
+
+ def __str__(self) -> str:
+ charset_to_try = ["utf-16", *list(NameObject.CHARSETS)]
+ for enc in charset_to_try:
+ try:
+ return self.decode(enc)
+ except UnicodeDecodeError:
+ pass
+ raise PdfReadError("Cannot decode ByteStringObject.")
+
+
+class TextStringObject(str, PdfObject): # noqa: SLOT000
+ """
+ A string object that has been decoded into a real unicode string.
+
+ If read from a PDF document, this string appeared to match the
+ PDFDocEncoding, or contained a UTF-16BE BOM mark to cause UTF-16 decoding
+ to occur.
+ """
+
+ autodetect_pdfdocencoding: bool
+ autodetect_utf16: bool
+ utf16_bom: bytes
+ _original_bytes: Optional[bytes] = None
+
+ def __new__(cls, value: Any) -> "TextStringObject":
+ original_bytes = None
+ if isinstance(value, bytes):
+ original_bytes = value
+ value = value.decode("charmap")
+ text_string_object = str.__new__(cls, value)
+ text_string_object._original_bytes = original_bytes
+ text_string_object.autodetect_utf16 = False
+ text_string_object.autodetect_pdfdocencoding = False
+ text_string_object.utf16_bom = b""
+ if original_bytes is not None and original_bytes[:2] in {codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE}:
+ # The value of `original_bytes` is only set for inputs being `bytes`.
+ # If this is UTF-16 data according to the BOM (first two characters),
+ # perform special handling. All other cases should not need any special conversion
+ # due to already being a string.
+ try:
+ text_string_object = str.__new__(cls, original_bytes.decode("utf-16"))
+ except UnicodeDecodeError as exception:
+ logger_warning(
+ f"{exception!s}\ninitial string:{exception.object!r}",
+ __name__,
+ )
+ text_string_object = str.__new__(cls, exception.object[: exception.start].decode("utf-16"))
+ text_string_object._original_bytes = original_bytes
+ text_string_object.autodetect_utf16 = True
+ text_string_object.utf16_bom = original_bytes[:2]
+ else:
+ try:
+ encode_pdfdocencoding(text_string_object)
+ text_string_object.autodetect_pdfdocencoding = True
+ except UnicodeEncodeError:
+ text_string_object.autodetect_utf16 = True
+ text_string_object.utf16_bom = codecs.BOM_UTF16_BE
+ return text_string_object
+
+ def clone(
+ self,
+ pdf_dest: Any,
+ force_duplicate: bool = False,
+ ignore_fields: Optional[Sequence[Union[str, int]]] = (),
+ ) -> "TextStringObject":
+ """Clone object into pdf_dest."""
+ obj = TextStringObject(self)
+ obj._original_bytes = self._original_bytes
+ obj.autodetect_pdfdocencoding = self.autodetect_pdfdocencoding
+ obj.autodetect_utf16 = self.autodetect_utf16
+ obj.utf16_bom = self.utf16_bom
+ return cast(
+ "TextStringObject", self._reference_clone(obj, pdf_dest, force_duplicate)
+ )
+
+ def hash_bin(self) -> int:
+ """
+ Used to detect modified object.
+
+ Returns:
+ Hash considering type and value.
+
+ """
+ return hash((self.__class__, self.original_bytes))
+
+ @property
+ def original_bytes(self) -> bytes:
+ """
+ It is occasionally possible that a text string object gets created where
+ a byte string object was expected due to the autodetection mechanism --
+ if that occurs, this "original_bytes" property can be used to
+ back-calculate what the original encoded bytes were.
+ """
+ if self._original_bytes is not None:
+ return self._original_bytes
+ return self.get_original_bytes()
+
+ def get_original_bytes(self) -> bytes:
+ # We're a text string object, but the library is trying to get our raw
+ # bytes. This can happen if we auto-detected this string as text, but
+ # we were wrong. It's pretty common. Return the original bytes that
+ # would have been used to create this object, based upon the autodetect
+ # method.
+ if self.autodetect_utf16:
+ if self.utf16_bom == codecs.BOM_UTF16_LE:
+ return codecs.BOM_UTF16_LE + self.encode("utf-16le")
+ if self.utf16_bom == codecs.BOM_UTF16_BE:
+ return codecs.BOM_UTF16_BE + self.encode("utf-16be")
+ return self.encode("utf-16be")
+ if self.autodetect_pdfdocencoding:
+ return encode_pdfdocencoding(self)
+ raise Exception("no information about original bytes") # pragma: no cover
+
+ def get_encoded_bytes(self) -> bytes:
+ # Try to write the string out as a PDFDocEncoding encoded string. It's
+ # nicer to look at in the PDF file. Sadly, we take a performance hit
+ # here for trying...
+ try:
+ if self._original_bytes is not None:
+ return self._original_bytes
+ if self.autodetect_utf16:
+ raise UnicodeEncodeError("", "forced", -1, -1, "")
+ bytearr = encode_pdfdocencoding(self)
+ except UnicodeEncodeError:
+ if self.utf16_bom == codecs.BOM_UTF16_LE:
+ bytearr = codecs.BOM_UTF16_LE + self.encode("utf-16le")
+ elif self.utf16_bom == codecs.BOM_UTF16_BE:
+ bytearr = codecs.BOM_UTF16_BE + self.encode("utf-16be")
+ else:
+ bytearr = self.encode("utf-16be")
+ return bytearr
+
+ def write_to_stream(
+ self, stream: StreamType, encryption_key: Union[None, str, bytes] = None
+ ) -> None:
+ if encryption_key is not None: # deprecated
+ deprecation_no_replacement(
+ "the encryption_key parameter of write_to_stream", "5.0.0"
+ )
+ bytearr = self.get_encoded_bytes()
+ stream.write(b"(")
+ for c_ in iter_unpack("c", bytearr):
+ c = cast(bytes, c_[0])
+ if not c.isalnum() and c != b" ":
+ # This:
+ # stream.write(rf"\{c:0>3o}".encode())
+ # gives
+ # https://github.com/davidhalter/parso/issues/207
+ stream.write(b"\\%03o" % ord(c))
+ else:
+ stream.write(c)
+ stream.write(b")")
+
+
+class NameObject(str, PdfObject): # noqa: SLOT000
+ delimiter_pattern = re.compile(rb"\s+|[\(\)<>\[\]{}/%]")
+ prefix = b"/"
+ renumber_table: ClassVar[dict[str, bytes]] = {
+ **{chr(i): f"#{i:02X}".encode() for i in b"#()<>[]{}/%"},
+ **{chr(i): f"#{i:02X}".encode() for i in range(33)},
+ }
+
+ def clone(
+ self,
+ pdf_dest: Any,
+ force_duplicate: bool = False,
+ ignore_fields: Optional[Sequence[Union[str, int]]] = (),
+ ) -> "NameObject":
+ """Clone object into pdf_dest."""
+ return cast(
+ "NameObject",
+ self._reference_clone(NameObject(self), pdf_dest, force_duplicate),
+ )
+
+ def hash_bin(self) -> int:
+ """
+ Used to detect modified object.
+
+ Returns:
+ Hash considering type and value.
+
+ """
+ return hash((self.__class__, self))
+
+ def write_to_stream(
+ self, stream: StreamType, encryption_key: Union[None, str, bytes] = None
+ ) -> None:
+ if encryption_key is not None: # deprecated
+ deprecation_no_replacement(
+ "the encryption_key parameter of write_to_stream", "5.0.0"
+ )
+ stream.write(self.renumber())
+
+ def renumber(self) -> bytes:
+ out = self[0].encode("utf-8")
+ if out != b"/":
+ deprecation_no_replacement(
+ f"Incorrect first char in NameObject, should start with '/': ({self})",
+ "5.0.0",
+ )
+ for c in self[1:]:
+ if c > "~":
+ for x in c.encode("utf-8"):
+ out += f"#{x:02X}".encode()
+ else:
+ try:
+ out += self.renumber_table[c]
+ except KeyError:
+ out += c.encode("utf-8")
+ return out
+
+ def _sanitize(self) -> "NameObject":
+ """
+ Sanitize the NameObject's name to be a valid PDF name part
+ (alphanumeric, underscore, hyphen). The _sanitize method replaces
+ spaces and any non-alphanumeric/non-underscore/non-hyphen with
+ underscores.
+
+ Returns:
+ NameObject with sanitized name.
+ """
+ name = str(self).removeprefix("/")
+ name = re.sub(r"\ ", "_", name)
+ name = re.sub(r"[^a-zA-Z0-9_-]", "_", name)
+ return NameObject("/" + name)
+
+ @classproperty
+ def surfix(cls) -> bytes: # noqa: N805
+ deprecation_with_replacement("surfix", "prefix", "5.0.0")
+ return b"/"
+
+ @staticmethod
+ def unnumber(sin: bytes) -> bytes:
+ i = sin.find(b"#", 0)
+ while i >= 0:
+ try:
+ sin = sin[:i] + unhexlify(sin[i + 1 : i + 3]) + sin[i + 3 :]
+ i = sin.find(b"#", i + 1)
+ except ValueError:
+ # if the 2 characters after # can not be converted to hex
+ # we change nothing and carry on
+ i = i + 1
+ return sin
+
+ CHARSETS = ("utf-8", "gbk", "latin1")
+
+ @staticmethod
+ def read_from_stream(stream: StreamType, pdf: Any) -> "NameObject": # PdfReader
+ name = stream.read(1)
+ if name != NameObject.prefix:
+ raise PdfReadError("Name read error")
+ name += read_until_regex(stream, NameObject.delimiter_pattern)
+ try:
+ # Name objects should represent irregular characters
+ # with a '#' followed by the symbol's hex number
+ name = NameObject.unnumber(name)
+ for enc in NameObject.CHARSETS:
+ try:
+ ret = name.decode(enc)
+ return NameObject(ret)
+ except Exception:
+ pass
+ raise UnicodeDecodeError("", name, 0, 0, "Code Not Found")
+ except (UnicodeEncodeError, UnicodeDecodeError) as e:
+ if not pdf.strict:
+ logger_warning(
+ f"Illegal character in NameObject ({name!r}), "
+ "you may need to adjust NameObject.CHARSETS",
+ __name__,
+ )
+ return NameObject(name.decode("charmap"))
+ raise PdfReadError(
+ f"Illegal character in NameObject ({name!r}). "
+ "You may need to adjust NameObject.CHARSETS.",
+ ) from e
+
+
+def encode_pdfdocencoding(unicode_string: str) -> bytes:
+ try:
+ return bytes([_pdfdoc_encoding_rev[k] for k in unicode_string])
+ except KeyError:
+ raise UnicodeEncodeError(
+ "pdfdocencoding",
+ unicode_string,
+ -1,
+ -1,
+ "does not exist in translation table",
+ )
+
+
+def is_null_or_none(x: Any) -> TypeGuard[Union[None, NullObject, IndirectObject]]:
+ """
+ Returns:
+ True if x is None or NullObject.
+
+ """
+ return x is None or (
+ isinstance(x, PdfObject)
+ and (x.get_object() is None or isinstance(x.get_object(), NullObject))
+ )
diff --git a/venv/lib/python3.12/site-packages/pypdf/generic/_data_structures.py b/venv/lib/python3.12/site-packages/pypdf/generic/_data_structures.py
new file mode 100644
index 0000000..b826652
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/generic/_data_structures.py
@@ -0,0 +1,1757 @@
+# Copyright (c) 2006, Mathieu Fenniak
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+
+
+__author__ = "Mathieu Fenniak"
+__author_email__ = "biziqe@mathieu.fenniak.net"
+
+import logging
+import re
+import sys
+from collections.abc import Iterable, Sequence
+from io import BytesIO
+from math import ceil
+from typing import (
+ Any,
+ Callable,
+ Optional,
+ Union,
+ cast,
+)
+
+from .._protocols import PdfReaderProtocol, PdfWriterProtocol, XmpInformationProtocol
+from .._utils import (
+ WHITESPACES,
+ StreamType,
+ deprecation_no_replacement,
+ logger_warning,
+ read_non_whitespace,
+ read_until_regex,
+ read_until_whitespace,
+ skip_over_comment,
+)
+from ..constants import (
+ CheckboxRadioButtonAttributes,
+ FieldDictionaryAttributes,
+ OutlineFontFlag,
+)
+from ..constants import FilterTypes as FT
+from ..constants import StreamAttributes as SA
+from ..constants import TypArguments as TA
+from ..constants import TypFitArguments as TF
+from ..errors import STREAM_TRUNCATED_PREMATURELY, PdfReadError, PdfStreamError
+from ._base import (
+ BooleanObject,
+ ByteStringObject,
+ FloatObject,
+ IndirectObject,
+ NameObject,
+ NullObject,
+ NumberObject,
+ PdfObject,
+ TextStringObject,
+ is_null_or_none,
+)
+from ._fit import Fit
+from ._image_inline import (
+ extract_inline__ascii85_decode,
+ extract_inline__ascii_hex_decode,
+ extract_inline__dct_decode,
+ extract_inline__run_length_decode,
+ extract_inline_default,
+)
+from ._utils import read_hex_string_from_stream, read_string_from_stream
+
+if sys.version_info >= (3, 11):
+ from typing import Self
+else:
+ from typing_extensions import Self
+
+logger = logging.getLogger(__name__)
+
+IndirectPattern = re.compile(rb"[+-]?(\d+)\s+(\d+)\s+R[^a-zA-Z]")
+
+
+class ArrayObject(list[Any], PdfObject):
+ def replicate(
+ self,
+ pdf_dest: PdfWriterProtocol,
+ ) -> "ArrayObject":
+ arr = cast(
+ "ArrayObject",
+ self._reference_clone(ArrayObject(), pdf_dest, False),
+ )
+ for data in self:
+ if hasattr(data, "replicate"):
+ arr.append(data.replicate(pdf_dest))
+ else:
+ arr.append(data)
+ return arr
+
+ def clone(
+ self,
+ pdf_dest: PdfWriterProtocol,
+ force_duplicate: bool = False,
+ ignore_fields: Optional[Sequence[Union[str, int]]] = (),
+ ) -> "ArrayObject":
+ """Clone object into pdf_dest."""
+ try:
+ if self.indirect_reference.pdf == pdf_dest and not force_duplicate: # type: ignore
+ return self
+ except Exception:
+ pass
+ arr = cast(
+ "ArrayObject",
+ self._reference_clone(ArrayObject(), pdf_dest, force_duplicate),
+ )
+ for data in self:
+ if isinstance(data, StreamObject):
+ dup = data._reference_clone(
+ data.clone(pdf_dest, force_duplicate, ignore_fields),
+ pdf_dest,
+ force_duplicate,
+ )
+ arr.append(dup.indirect_reference)
+ elif hasattr(data, "clone"):
+ arr.append(data.clone(pdf_dest, force_duplicate, ignore_fields))
+ else:
+ arr.append(data)
+ return arr
+
+ def hash_bin(self) -> int:
+ """
+ Used to detect modified object.
+
+ Returns:
+ Hash considering type and value.
+
+ """
+ return hash((self.__class__, tuple(x.hash_bin() for x in self)))
+
+ def items(self) -> Iterable[Any]:
+ """Emulate DictionaryObject.items for a list (index, object)."""
+ return enumerate(self)
+
+ def _to_lst(self, lst: Any) -> list[Any]:
+ # Convert to list, internal
+ if isinstance(lst, (list, tuple, set)):
+ pass
+ elif isinstance(lst, PdfObject):
+ lst = [lst]
+ elif isinstance(lst, str):
+ if lst[0] == "/":
+ lst = [NameObject(lst)]
+ else:
+ lst = [TextStringObject(lst)]
+ elif isinstance(lst, bytes):
+ lst = [ByteStringObject(lst)]
+ else: # for numbers,...
+ lst = [lst]
+ return lst
+
+ def __add__(self, lst: Any) -> "ArrayObject":
+ """
+ Allow extension by adding list or add one element only
+
+ Args:
+ lst: any list, tuples are extended the list.
+ other types(numbers,...) will be appended.
+ if str is passed it will be converted into TextStringObject
+ or NameObject (if starting with "/")
+ if bytes is passed it will be converted into ByteStringObject
+
+ Returns:
+ ArrayObject with all elements
+
+ """
+ temp = ArrayObject(self)
+ temp.extend(self._to_lst(lst))
+ return temp
+
+ def __iadd__(self, lst: Any) -> Self:
+ """
+ Allow extension by adding list or add one element only
+
+ Args:
+ lst: any list, tuples are extended the list.
+ other types(numbers,...) will be appended.
+ if str is passed it will be converted into TextStringObject
+ or NameObject (if starting with "/")
+ if bytes is passed it will be converted into ByteStringObject
+
+ """
+ self.extend(self._to_lst(lst))
+ return self
+
+ def __isub__(self, lst: Any) -> Self:
+ """Allow to remove items"""
+ for x in self._to_lst(lst):
+ try:
+ index = self.index(x)
+ del self[index]
+ except ValueError:
+ pass
+ return self
+
+ def write_to_stream(
+ self, stream: StreamType, encryption_key: Union[None, str, bytes] = None
+ ) -> None:
+ if encryption_key is not None: # deprecated
+ deprecation_no_replacement(
+ "the encryption_key parameter of write_to_stream", "5.0.0"
+ )
+ stream.write(b"[")
+ for data in self:
+ stream.write(b" ")
+ data.write_to_stream(stream)
+ stream.write(b" ]")
+
+ @staticmethod
+ def read_from_stream(
+ stream: StreamType,
+ pdf: Optional[PdfReaderProtocol],
+ forced_encoding: Union[None, str, list[str], dict[int, str]] = None,
+ ) -> "ArrayObject":
+ arr = ArrayObject()
+ tmp = stream.read(1)
+ if tmp != b"[":
+ raise PdfReadError("Could not read array")
+ while True:
+ # skip leading whitespace
+ tok = stream.read(1)
+ while tok.isspace():
+ tok = stream.read(1)
+ if tok == b"":
+ break
+ if tok == b"%":
+ stream.seek(-1, 1)
+ skip_over_comment(stream)
+ continue
+ stream.seek(-1, 1)
+ # check for array ending
+ peek_ahead = stream.read(1)
+ if peek_ahead == b"]":
+ break
+ stream.seek(-1, 1)
+ # read and append object
+ arr.append(read_object(stream, pdf, forced_encoding))
+ return arr
+
+
+class DictionaryObject(dict[Any, Any], PdfObject):
+ def replicate(
+ self,
+ pdf_dest: PdfWriterProtocol,
+ ) -> "DictionaryObject":
+ d__ = cast(
+ "DictionaryObject",
+ self._reference_clone(self.__class__(), pdf_dest, False),
+ )
+ for k, v in self.items():
+ d__[k.replicate(pdf_dest)] = (
+ v.replicate(pdf_dest) if hasattr(v, "replicate") else v
+ )
+ return d__
+
+ def clone(
+ self,
+ pdf_dest: PdfWriterProtocol,
+ force_duplicate: bool = False,
+ ignore_fields: Optional[Sequence[Union[str, int]]] = (),
+ ) -> "DictionaryObject":
+ """Clone object into pdf_dest."""
+ try:
+ if self.indirect_reference.pdf == pdf_dest and not force_duplicate: # type: ignore
+ return self
+ except Exception:
+ pass
+
+ visited: set[tuple[int, int]] = set() # (idnum, generation)
+ d__ = cast(
+ "DictionaryObject",
+ self._reference_clone(self.__class__(), pdf_dest, force_duplicate),
+ )
+ if ignore_fields is None:
+ ignore_fields = []
+ if len(d__.keys()) == 0:
+ d__._clone(self, pdf_dest, force_duplicate, ignore_fields, visited)
+ return d__
+
+ def _clone(
+ self,
+ src: "DictionaryObject",
+ pdf_dest: PdfWriterProtocol,
+ force_duplicate: bool,
+ ignore_fields: Optional[Sequence[Union[str, int]]],
+ visited: set[tuple[int, int]], # (idnum, generation)
+ ) -> None:
+ """
+ Update the object from src.
+
+ Args:
+ src: "DictionaryObject":
+ pdf_dest:
+ force_duplicate:
+ ignore_fields:
+
+ """
+ # First we remove the ignore_fields
+ # that are for a limited number of levels
+ assert ignore_fields is not None
+ ignore_fields = list(ignore_fields)
+ x = 0
+ while x < len(ignore_fields):
+ if isinstance(ignore_fields[x], int):
+ if cast(int, ignore_fields[x]) <= 0:
+ del ignore_fields[x]
+ del ignore_fields[x]
+ continue
+ ignore_fields[x] -= 1 # type:ignore
+ x += 1
+ # Check if this is a chain list, we need to loop to prevent recur
+ if any(
+ field not in ignore_fields
+ and field in src
+ and isinstance(src.raw_get(field), IndirectObject)
+ and isinstance(src[field], DictionaryObject)
+ and (
+ src.get("/Type", None) is None
+ or cast(DictionaryObject, src[field]).get("/Type", None) is None
+ or src.get("/Type", None)
+ == cast(DictionaryObject, src[field]).get("/Type", None)
+ )
+ for field in ["/Next", "/Prev", "/N", "/V"]
+ ):
+ ignore_fields = list(ignore_fields)
+ for lst in (("/Next", "/Prev"), ("/N", "/V")):
+ for k in lst:
+ objs = []
+ if (
+ k in src
+ and k not in self
+ and isinstance(src.raw_get(k), IndirectObject)
+ and isinstance(src[k], DictionaryObject)
+ # If need to go further the idea is to check
+ # that the types are the same
+ and (
+ src.get("/Type", None) is None
+ or cast(DictionaryObject, src[k]).get("/Type", None) is None
+ or src.get("/Type", None)
+ == cast(DictionaryObject, src[k]).get("/Type", None)
+ )
+ ):
+ cur_obj: Optional[DictionaryObject] = cast(
+ "DictionaryObject", src[k]
+ )
+ prev_obj: Optional[DictionaryObject] = self
+ while cur_obj is not None:
+ clon = cast(
+ "DictionaryObject",
+ cur_obj._reference_clone(
+ cur_obj.__class__(), pdf_dest, force_duplicate
+ ),
+ )
+ # Check to see if we've previously processed our item
+ if clon.indirect_reference is not None:
+ idnum = clon.indirect_reference.idnum
+ generation = clon.indirect_reference.generation
+ if (idnum, generation) in visited:
+ cur_obj = None
+ break
+ visited.add((idnum, generation))
+ objs.append((cur_obj, clon))
+ assert prev_obj is not None
+ prev_obj[NameObject(k)] = clon.indirect_reference
+ prev_obj = clon
+ try:
+ if cur_obj == src:
+ cur_obj = None
+ else:
+ cur_obj = cast("DictionaryObject", cur_obj[k])
+ except Exception:
+ cur_obj = None
+ for s, c in objs:
+ c._clone(
+ s, pdf_dest, force_duplicate, ignore_fields, visited
+ )
+
+ for k, v in src.items():
+ if k not in ignore_fields:
+ if isinstance(v, StreamObject):
+ if not hasattr(v, "indirect_reference"):
+ v.indirect_reference = None
+ vv = v.clone(pdf_dest, force_duplicate, ignore_fields)
+ assert vv.indirect_reference is not None
+ self[k.clone(pdf_dest)] = vv.indirect_reference
+ elif k not in self:
+ self[NameObject(k)] = (
+ v.clone(pdf_dest, force_duplicate, ignore_fields)
+ if hasattr(v, "clone")
+ else v
+ )
+
+ def hash_bin(self) -> int:
+ """
+ Used to detect modified object.
+
+ Returns:
+ Hash considering type and value.
+
+ """
+ return hash(
+ (self.__class__, tuple(((k, v.hash_bin()) for k, v in self.items())))
+ )
+
+ def raw_get(self, key: Any) -> Any:
+ return dict.__getitem__(self, key)
+
+ def get_inherited(self, key: str, default: Any = None) -> Any:
+ """
+ Returns the value of a key or from the parent if not found.
+ If not found returns default.
+
+ Args:
+ key: string identifying the field to return
+
+ default: default value to return
+
+ Returns:
+ Current key or inherited one, otherwise default value.
+
+ """
+ if key in self:
+ return self[key]
+ try:
+ if "/Parent" not in self:
+ return default
+ raise KeyError("Not present")
+ except KeyError:
+ return cast("DictionaryObject", self["/Parent"].get_object()).get_inherited(
+ key, default
+ )
+
+ def __setitem__(self, key: Any, value: Any) -> Any:
+ if not isinstance(key, PdfObject):
+ raise ValueError("Key must be a PdfObject")
+ if not isinstance(value, PdfObject):
+ raise ValueError("Value must be a PdfObject")
+ return dict.__setitem__(self, key, value)
+
+ def setdefault(self, key: Any, value: Optional[Any] = None) -> Any:
+ if not isinstance(key, PdfObject):
+ raise ValueError("Key must be a PdfObject")
+ if not isinstance(value, PdfObject):
+ raise ValueError("Value must be a PdfObject")
+ return dict.setdefault(self, key, value)
+
+ def __getitem__(self, key: Any) -> PdfObject:
+ return dict.__getitem__(self, key).get_object()
+
+ @property
+ def xmp_metadata(self) -> Optional[XmpInformationProtocol]:
+ """
+ Retrieve XMP (Extensible Metadata Platform) data relevant to this
+ object, if available.
+
+ See Table 347 — Additional entries in a metadata stream dictionary.
+
+ Returns:
+ Returns a :class:`~pypdf.xmp.XmpInformation` instance
+ that can be used to access XMP metadata from the document. Can also
+ return None if no metadata was found on the document root.
+
+ """
+ from ..xmp import XmpInformation # noqa: PLC0415
+
+ metadata = self.get("/Metadata", None)
+ if is_null_or_none(metadata):
+ return None
+ assert metadata is not None, "mypy"
+ metadata = metadata.get_object()
+ return XmpInformation(metadata)
+
+ def write_to_stream(
+ self, stream: StreamType, encryption_key: Union[None, str, bytes] = None
+ ) -> None:
+ if encryption_key is not None: # deprecated
+ deprecation_no_replacement(
+ "the encryption_key parameter of write_to_stream", "5.0.0"
+ )
+ stream.write(b"<<\n")
+ for key, value in self.items():
+ if len(key) > 2 and key[1] == "%" and key[-1] == "%":
+ continue
+ key.write_to_stream(stream, encryption_key)
+ stream.write(b" ")
+ value.write_to_stream(stream)
+ stream.write(b"\n")
+ stream.write(b">>")
+
+ @staticmethod
+ def read_from_stream(
+ stream: StreamType,
+ pdf: Optional[PdfReaderProtocol],
+ forced_encoding: Union[None, str, list[str], dict[int, str]] = None,
+ ) -> "DictionaryObject":
+ def get_next_obj_pos(
+ p: int, p1: int, rem_gens: list[int], pdf: PdfReaderProtocol
+ ) -> int:
+ out = p1
+ for gen in rem_gens:
+ loc = pdf.xref[gen]
+ try:
+ values = [x for x in loc.values() if p < x <= p1]
+ if values:
+ out = min(out, *values)
+ except ValueError:
+ pass
+ return out
+
+ def read_unsized_from_stream(
+ stream: StreamType, pdf: PdfReaderProtocol
+ ) -> bytes:
+ # we are just pointing at beginning of the stream
+ eon = get_next_obj_pos(stream.tell(), 2**32, list(pdf.xref), pdf) - 1
+ curr = stream.tell()
+ rw = stream.read(eon - stream.tell())
+ p = rw.find(b"endstream")
+ if p < 0:
+ raise PdfReadError(
+ f"Unable to find 'endstream' marker for obj starting at {curr}."
+ )
+ stream.seek(curr + p + 9)
+ return rw[: p - 1]
+
+ tmp = stream.read(2)
+ if tmp != b"<<":
+ raise PdfReadError(
+ f"Dictionary read error at byte {hex(stream.tell())}: "
+ "stream must begin with '<<'"
+ )
+ data: dict[Any, Any] = {}
+ while True:
+ tok = read_non_whitespace(stream)
+ if tok == b"\x00":
+ continue
+ if tok == b"%":
+ stream.seek(-1, 1)
+ skip_over_comment(stream)
+ continue
+ if not tok:
+ raise PdfStreamError(STREAM_TRUNCATED_PREMATURELY)
+
+ if tok == b">":
+ stream.read(1)
+ break
+ stream.seek(-1, 1)
+ try:
+ try:
+ key = read_object(stream, pdf)
+ if isinstance(key, NullObject):
+ break
+ if not isinstance(key, NameObject):
+ raise PdfReadError(
+ f"Expecting a NameObject for key but found {key!r}"
+ )
+ except PdfReadError as exc:
+ if pdf is not None and pdf.strict:
+ raise
+ logger_warning(exc.__repr__(), __name__)
+ continue
+ tok = read_non_whitespace(stream)
+ stream.seek(-1, 1)
+ value = read_object(stream, pdf, forced_encoding)
+ except Exception as exc:
+ if pdf is not None and pdf.strict:
+ raise PdfReadError(exc.__repr__())
+ logger_warning(exc.__repr__(), __name__)
+ retval = DictionaryObject()
+ retval.update(data)
+ return retval # return partial data
+
+ if not data.get(key):
+ data[key] = value
+ else:
+ # multiple definitions of key not permitted
+ msg = (
+ f"Multiple definitions in dictionary at byte "
+ f"{hex(stream.tell())} for key {key}"
+ )
+ if pdf is not None and pdf.strict:
+ raise PdfReadError(msg)
+ logger_warning(msg, __name__)
+
+ pos = stream.tell()
+ s = read_non_whitespace(stream)
+ if s == b"s" and stream.read(5) == b"tream":
+ eol = stream.read(1)
+ # Occasional PDF file output has spaces after 'stream' keyword but before EOL.
+ # patch provided by Danial Sandler
+ while eol == b" ":
+ eol = stream.read(1)
+ if eol not in (b"\n", b"\r"):
+ raise PdfStreamError("Stream data must be followed by a newline")
+ if eol == b"\r" and stream.read(1) != b"\n":
+ stream.seek(-1, 1)
+ # this is a stream object, not a dictionary
+ if SA.LENGTH not in data:
+ if pdf is not None and pdf.strict:
+ raise PdfStreamError("Stream length not defined")
+ logger_warning(
+ f"Stream length not defined @pos={stream.tell()}", __name__
+ )
+ data[NameObject(SA.LENGTH)] = NumberObject(-1)
+ length = data[SA.LENGTH]
+ if isinstance(length, IndirectObject):
+ t = stream.tell()
+ assert pdf is not None, "mypy"
+ length = pdf.get_object(length)
+ stream.seek(t, 0)
+ if length is None: # if the PDF is damaged
+ length = -1
+ pstart = stream.tell()
+ if length >= 0:
+ data["__streamdata__"] = stream.read(length)
+ else:
+ data["__streamdata__"] = read_until_regex(
+ stream, re.compile(b"endstream")
+ )
+ e = read_non_whitespace(stream)
+ ndstream = stream.read(8)
+ if (e + ndstream) != b"endstream":
+ # the odd PDF file has a length that is too long, so
+ # we need to read backwards to find the "endstream" ending.
+ # ReportLab (unknown version) generates files with this bug,
+ # and Python users into PDF files tend to be our audience.
+ # we need to do this to correct the streamdata and chop off
+ # an extra character.
+ pos = stream.tell()
+ stream.seek(-10, 1)
+ end = stream.read(9)
+ if end == b"endstream":
+ # we found it by looking back one character further.
+ data["__streamdata__"] = data["__streamdata__"][:-1]
+ elif pdf is not None and not pdf.strict:
+ stream.seek(pstart, 0)
+ data["__streamdata__"] = read_unsized_from_stream(stream, pdf)
+ pos = stream.tell()
+ else:
+ stream.seek(pos, 0)
+ raise PdfReadError(
+ "Unable to find 'endstream' marker after stream at byte "
+ f"{hex(stream.tell())} (nd='{ndstream!r}', end='{end!r}')."
+ )
+ else:
+ stream.seek(pos, 0)
+ if "__streamdata__" in data:
+ return StreamObject.initialize_from_dictionary(data)
+ retval = DictionaryObject()
+ retval.update(data)
+ return retval
+
+
+class TreeObject(DictionaryObject):
+ def __init__(self, dct: Optional[DictionaryObject] = None) -> None:
+ DictionaryObject.__init__(self)
+ if dct:
+ self.update(dct)
+
+ def has_children(self) -> bool:
+ return "/First" in self
+
+ def __iter__(self) -> Any:
+ return self.children()
+
+ def children(self) -> Iterable[Any]:
+ if not self.has_children():
+ return
+
+ child_ref = self[NameObject("/First")]
+ child = child_ref.get_object()
+ while True:
+ yield child
+ if child == self[NameObject("/Last")]:
+ return
+ child_ref = child.get(NameObject("/Next")) # type: ignore
+ if is_null_or_none(child_ref):
+ return
+ child = child_ref.get_object()
+
+ def add_child(self, child: Any, pdf: PdfWriterProtocol) -> None:
+ self.insert_child(child, None, pdf)
+
+ def inc_parent_counter_default(
+ self, parent: Union[None, IndirectObject, "TreeObject"], n: int
+ ) -> None:
+ if is_null_or_none(parent):
+ return
+ assert parent is not None, "mypy"
+ parent = cast("TreeObject", parent.get_object())
+ if "/Count" in parent:
+ parent[NameObject("/Count")] = NumberObject(
+ max(0, cast(int, parent[NameObject("/Count")]) + n)
+ )
+ self.inc_parent_counter_default(parent.get("/Parent", None), n)
+
+ def inc_parent_counter_outline(
+ self, parent: Union[None, IndirectObject, "TreeObject"], n: int
+ ) -> None:
+ if is_null_or_none(parent):
+ return
+ assert parent is not None, "mypy"
+ parent = cast("TreeObject", parent.get_object())
+ # BooleanObject requires comparison with == not is
+ opn = parent.get("/%is_open%", True) == True # noqa: E712
+ c = cast(int, parent.get("/Count", 0))
+ if c < 0:
+ c = abs(c)
+ parent[NameObject("/Count")] = NumberObject((c + n) * (1 if opn else -1))
+ if not opn:
+ return
+ self.inc_parent_counter_outline(parent.get("/Parent", None), n)
+
+ def insert_child(
+ self,
+ child: Any,
+ before: Any,
+ pdf: PdfWriterProtocol,
+ inc_parent_counter: Optional[Callable[..., Any]] = None,
+ ) -> IndirectObject:
+ if inc_parent_counter is None:
+ inc_parent_counter = self.inc_parent_counter_default
+ child_obj = child.get_object()
+ child = child.indirect_reference # get_reference(child_obj)
+
+ prev: Optional[DictionaryObject]
+ if "/First" not in self: # no child yet
+ self[NameObject("/First")] = child
+ self[NameObject("/Count")] = NumberObject(0)
+ self[NameObject("/Last")] = child
+ child_obj[NameObject("/Parent")] = self.indirect_reference
+ inc_parent_counter(self, child_obj.get("/Count", 1))
+ if "/Next" in child_obj:
+ del child_obj["/Next"]
+ if "/Prev" in child_obj:
+ del child_obj["/Prev"]
+ return child
+ prev = cast("DictionaryObject", self["/Last"])
+
+ while prev.indirect_reference != before:
+ if "/Next" in prev:
+ prev = cast("TreeObject", prev["/Next"])
+ else: # append at the end
+ prev[NameObject("/Next")] = cast("TreeObject", child)
+ child_obj[NameObject("/Prev")] = prev.indirect_reference
+ child_obj[NameObject("/Parent")] = self.indirect_reference
+ if "/Next" in child_obj:
+ del child_obj["/Next"]
+ self[NameObject("/Last")] = child
+ inc_parent_counter(self, child_obj.get("/Count", 1))
+ return child
+ try: # insert as first or in the middle
+ assert isinstance(prev["/Prev"], DictionaryObject)
+ prev["/Prev"][NameObject("/Next")] = child
+ child_obj[NameObject("/Prev")] = prev["/Prev"]
+ except Exception: # it means we are inserting in first position
+ del child_obj["/Next"]
+ child_obj[NameObject("/Next")] = prev
+ prev[NameObject("/Prev")] = child
+ child_obj[NameObject("/Parent")] = self.indirect_reference
+ inc_parent_counter(self, child_obj.get("/Count", 1))
+ return child
+
+ def _remove_node_from_tree(
+ self, prev: Any, prev_ref: Any, cur: Any, last: Any
+ ) -> None:
+ """
+ Adjust the pointers of the linked list and tree node count.
+
+ Args:
+ prev:
+ prev_ref:
+ cur:
+ last:
+
+ """
+ next_ref = cur.get(NameObject("/Next"), None)
+ if prev is None:
+ if next_ref:
+ # Removing first tree node
+ next_obj = next_ref.get_object()
+ del next_obj[NameObject("/Prev")]
+ self[NameObject("/First")] = next_ref
+ self[NameObject("/Count")] = NumberObject(
+ self[NameObject("/Count")] - 1 # type: ignore
+ )
+
+ else:
+ # Removing only tree node
+ self[NameObject("/Count")] = NumberObject(0)
+ del self[NameObject("/First")]
+ if NameObject("/Last") in self:
+ del self[NameObject("/Last")]
+ else:
+ if next_ref:
+ # Removing middle tree node
+ next_obj = next_ref.get_object()
+ next_obj[NameObject("/Prev")] = prev_ref
+ prev[NameObject("/Next")] = next_ref
+ else:
+ # Removing last tree node
+ assert cur == last
+ del prev[NameObject("/Next")]
+ self[NameObject("/Last")] = prev_ref
+ self[NameObject("/Count")] = NumberObject(self[NameObject("/Count")] - 1) # type: ignore
+
+ def remove_child(self, child: Any) -> None:
+ child_obj = child.get_object()
+ child = child_obj.indirect_reference
+
+ if NameObject("/Parent") not in child_obj:
+ raise ValueError("Removed child does not appear to be a tree item")
+ if child_obj[NameObject("/Parent")] != self:
+ raise ValueError("Removed child is not a member of this tree")
+
+ found = False
+ prev_ref = None
+ prev = None
+ cur_ref: Optional[Any] = self[NameObject("/First")]
+ cur: Optional[dict[str, Any]] = cur_ref.get_object() # type: ignore
+ last_ref = self[NameObject("/Last")]
+ last = last_ref.get_object()
+ while cur is not None:
+ if cur == child_obj:
+ self._remove_node_from_tree(prev, prev_ref, cur, last)
+ found = True
+ break
+
+ # Go to the next node
+ prev_ref = cur_ref
+ prev = cur
+ if NameObject("/Next") in cur:
+ cur_ref = cur[NameObject("/Next")]
+ cur = cur_ref.get_object()
+ else:
+ cur_ref = None
+ cur = None
+
+ if not found:
+ raise ValueError("Removal couldn't find item in tree")
+
+ _reset_node_tree_relationship(child_obj)
+
+ def remove_from_tree(self) -> None:
+ """Remove the object from the tree it is in."""
+ if NameObject("/Parent") not in self:
+ raise ValueError("Removed child does not appear to be a tree item")
+ cast("TreeObject", self["/Parent"]).remove_child(self)
+
+ def empty_tree(self) -> None:
+ for child in self:
+ child_obj = child.get_object()
+ _reset_node_tree_relationship(child_obj)
+
+ if NameObject("/Count") in self:
+ del self[NameObject("/Count")]
+ if NameObject("/First") in self:
+ del self[NameObject("/First")]
+ if NameObject("/Last") in self:
+ del self[NameObject("/Last")]
+
+
+def _reset_node_tree_relationship(child_obj: Any) -> None:
+ """
+ Call this after a node has been removed from a tree.
+
+ This resets the nodes attributes in respect to that tree.
+
+ Args:
+ child_obj:
+
+ """
+ del child_obj[NameObject("/Parent")]
+ if NameObject("/Next") in child_obj:
+ del child_obj[NameObject("/Next")]
+ if NameObject("/Prev") in child_obj:
+ del child_obj[NameObject("/Prev")]
+
+
+class StreamObject(DictionaryObject):
+ def __init__(self) -> None:
+ self._data: bytes = b""
+ self.decoded_self: Optional[DecodedStreamObject] = None
+
+ def replicate(
+ self,
+ pdf_dest: PdfWriterProtocol,
+ ) -> "StreamObject":
+ d__ = cast(
+ "StreamObject",
+ self._reference_clone(self.__class__(), pdf_dest, False),
+ )
+ d__._data = self._data
+ try:
+ decoded_self = self.decoded_self
+ if decoded_self is None:
+ self.decoded_self = None
+ else:
+ self.decoded_self = cast(
+ "DecodedStreamObject", decoded_self.replicate(pdf_dest)
+ )
+ except Exception:
+ pass
+ for k, v in self.items():
+ d__[k.replicate(pdf_dest)] = (
+ v.replicate(pdf_dest) if hasattr(v, "replicate") else v
+ )
+ return d__
+
+ def _clone(
+ self,
+ src: DictionaryObject,
+ pdf_dest: PdfWriterProtocol,
+ force_duplicate: bool,
+ ignore_fields: Optional[Sequence[Union[str, int]]],
+ visited: set[tuple[int, int]],
+ ) -> None:
+ """
+ Update the object from src.
+
+ Args:
+ src:
+ pdf_dest:
+ force_duplicate:
+ ignore_fields:
+
+ """
+ self._data = cast("StreamObject", src)._data
+ try:
+ decoded_self = cast("StreamObject", src).decoded_self
+ if decoded_self is None:
+ self.decoded_self = None
+ else:
+ self.decoded_self = cast(
+ "DecodedStreamObject",
+ decoded_self.clone(pdf_dest, force_duplicate, ignore_fields),
+ )
+ except Exception:
+ pass
+ super()._clone(src, pdf_dest, force_duplicate, ignore_fields, visited)
+
+ def hash_bin(self) -> int:
+ """
+ Used to detect modified object.
+
+ Returns:
+ Hash considering type and value.
+
+ """
+ # Use _data to prevent errors on non-decoded streams.
+ return hash((super().hash_bin(), self._data))
+
+ def get_data(self) -> bytes:
+ return self._data
+
+ def set_data(self, data: bytes) -> None:
+ self._data = data
+
+ def hash_value_data(self) -> bytes:
+ data = super().hash_value_data()
+ data += self.get_data()
+ return data
+
+ def write_to_stream(
+ self, stream: StreamType, encryption_key: Union[None, str, bytes] = None
+ ) -> None:
+ if encryption_key is not None: # deprecated
+ deprecation_no_replacement(
+ "the encryption_key parameter of write_to_stream", "5.0.0"
+ )
+ self[NameObject(SA.LENGTH)] = NumberObject(len(self._data))
+ DictionaryObject.write_to_stream(self, stream)
+ del self[SA.LENGTH]
+ stream.write(b"\nstream\n")
+ stream.write(self._data)
+ stream.write(b"\nendstream")
+
+ @staticmethod
+ def initialize_from_dictionary(
+ data: dict[str, Any]
+ ) -> Union["EncodedStreamObject", "DecodedStreamObject"]:
+ retval: Union[EncodedStreamObject, DecodedStreamObject]
+ if SA.FILTER in data:
+ retval = EncodedStreamObject()
+ else:
+ retval = DecodedStreamObject()
+ retval._data = data["__streamdata__"]
+ del data["__streamdata__"]
+ if SA.LENGTH in data:
+ del data[SA.LENGTH]
+ retval.update(data)
+ return retval
+
+ def flate_encode(self, level: int = -1) -> "EncodedStreamObject":
+ from ..filters import FlateDecode # noqa: PLC0415
+
+ if SA.FILTER in self:
+ f = self[SA.FILTER]
+ if isinstance(f, ArrayObject):
+ f = ArrayObject([NameObject(FT.FLATE_DECODE), *f])
+ try:
+ params = ArrayObject(
+ [NullObject(), *self.get(SA.DECODE_PARMS, ArrayObject())]
+ )
+ except TypeError:
+ # case of error where the * operator is not working (not an array
+ params = ArrayObject(
+ [NullObject(), self.get(SA.DECODE_PARMS, ArrayObject())]
+ )
+ else:
+ f = ArrayObject([NameObject(FT.FLATE_DECODE), f])
+ params = ArrayObject(
+ [NullObject(), self.get(SA.DECODE_PARMS, NullObject())]
+ )
+ else:
+ f = NameObject(FT.FLATE_DECODE)
+ params = None
+ retval = EncodedStreamObject()
+ retval.update(self)
+ retval[NameObject(SA.FILTER)] = f
+ if params is not None:
+ retval[NameObject(SA.DECODE_PARMS)] = params
+ retval._data = FlateDecode.encode(self._data, level)
+ return retval
+
+ def decode_as_image(self, pillow_parameters: Union[dict[str, Any], None] = None) -> Any:
+ """
+ Try to decode the stream object as an image
+
+ Args:
+ pillow_parameters: parameters provided to Pillow Image.save() method,
+ cf.
+
+ Returns:
+ a PIL image if proper decoding has been found
+ Raises:
+ Exception: Errors during decoding will be reported.
+ It is recommended to catch exceptions to prevent
+ stops in your program.
+
+ """
+ from .._xobj_image_helpers import _xobj_to_image # noqa: PLC0415
+
+ if self.get("/Subtype", "") != "/Image":
+ try:
+ msg = f"{self.indirect_reference} does not seem to be an Image" # pragma: no cover
+ except AttributeError:
+ msg = f"{self.__repr__()} object does not seem to be an Image" # pragma: no cover
+ logger_warning(msg, __name__)
+ extension, _, img = _xobj_to_image(self, pillow_parameters)
+ if extension is None:
+ return None # pragma: no cover
+ return img
+
+
+class DecodedStreamObject(StreamObject):
+ pass
+
+
+class EncodedStreamObject(StreamObject):
+ def __init__(self) -> None:
+ self.decoded_self: Optional[DecodedStreamObject] = None
+
+ # This overrides the parent method
+ def get_data(self) -> bytes:
+ from ..filters import decode_stream_data # noqa: PLC0415
+
+ if self.decoded_self is not None:
+ # Cached version of decoded object
+ return self.decoded_self.get_data()
+
+ # Create decoded object
+ decoded = DecodedStreamObject()
+ decoded.set_data(decode_stream_data(self))
+ for key, value in self.items():
+ if key not in (SA.LENGTH, SA.FILTER, SA.DECODE_PARMS):
+ decoded[key] = value
+ self.decoded_self = decoded
+ return decoded.get_data()
+
+ # This overrides the parent method:
+ def set_data(self, data: bytes) -> None:
+ from ..filters import FlateDecode # noqa: PLC0415
+
+ if self.get(SA.FILTER, "") in (FT.FLATE_DECODE, [FT.FLATE_DECODE]):
+ if not isinstance(data, bytes):
+ raise TypeError("Data must be bytes")
+ if self.decoded_self is None:
+ self.get_data() # to create self.decoded_self
+ assert self.decoded_self is not None, "mypy"
+ self.decoded_self.set_data(data)
+ super().set_data(FlateDecode.encode(data))
+ else:
+ raise PdfReadError(
+ "Streams encoded with a filter different from FlateDecode are not supported"
+ )
+
+
+class ContentStream(DecodedStreamObject):
+ """
+ In order to be fast, this data structure can contain either:
+
+ * raw data in ._data
+ * parsed stream operations in ._operations.
+
+ At any time, ContentStream object can either have both of those fields defined,
+ or one field defined and the other set to None.
+
+ These fields are "rebuilt" lazily, when accessed:
+
+ * when .get_data() is called, if ._data is None, it is rebuilt from ._operations.
+ * when .operations is called, if ._operations is None, it is rebuilt from ._data.
+
+ Conversely, these fields can be invalidated:
+
+ * when .set_data() is called, ._operations is set to None.
+ * when .operations is set, ._data is set to None.
+ """
+
+ def __init__(
+ self,
+ stream: Any,
+ pdf: Any,
+ forced_encoding: Union[None, str, list[str], dict[int, str]] = None,
+ ) -> None:
+ self.pdf = pdf
+ self._operations: list[tuple[Any, bytes]] = []
+
+ # stream may be a StreamObject or an ArrayObject containing
+ # StreamObjects to be concatenated together.
+ if stream is None:
+ super().set_data(b"")
+ else:
+ stream = stream.get_object()
+ if isinstance(stream, ArrayObject):
+ data = b""
+ for s in stream:
+ s_resolved = s.get_object()
+ if isinstance(s_resolved, NullObject):
+ continue
+ if not isinstance(s_resolved, StreamObject):
+ # No need to emit an exception here for now - the PDF structure
+ # seems to already be broken beforehand in these cases.
+ logger_warning(
+ f"Expected StreamObject, got {type(s_resolved).__name__} instead. Data might be wrong.",
+ __name__
+ )
+ else:
+ data += s_resolved.get_data()
+ if len(data) == 0 or data[-1] != b"\n":
+ data += b"\n"
+ super().set_data(bytes(data))
+ else:
+ stream_data = stream.get_data()
+ assert stream_data is not None
+ super().set_data(stream_data)
+ self.forced_encoding = forced_encoding
+
+ def replicate(
+ self,
+ pdf_dest: PdfWriterProtocol,
+ ) -> "ContentStream":
+ d__ = cast(
+ "ContentStream",
+ self._reference_clone(self.__class__(None, None), pdf_dest, False),
+ )
+ d__._data = self._data
+ try:
+ decoded_self = self.decoded_self
+ if decoded_self is None:
+ self.decoded_self = None
+ else:
+ self.decoded_self = cast(
+ "DecodedStreamObject", decoded_self.replicate(pdf_dest)
+ )
+ except Exception:
+ pass
+ for k, v in self.items():
+ d__[k.replicate(pdf_dest)] = (
+ v.replicate(pdf_dest) if hasattr(v, "replicate") else v
+ )
+ return d__
+ d__.set_data(self._data)
+ d__.pdf = pdf_dest
+ d__._operations = list(self._operations)
+ d__.forced_encoding = self.forced_encoding
+ return d__
+
+ def clone(
+ self,
+ pdf_dest: Any,
+ force_duplicate: bool = False,
+ ignore_fields: Optional[Sequence[Union[str, int]]] = (),
+ ) -> "ContentStream":
+ """
+ Clone object into pdf_dest.
+
+ Args:
+ pdf_dest:
+ force_duplicate:
+ ignore_fields:
+
+ Returns:
+ The cloned ContentStream
+
+ """
+ try:
+ if self.indirect_reference.pdf == pdf_dest and not force_duplicate: # type: ignore
+ return self
+ except Exception:
+ pass
+
+ visited: set[tuple[int, int]] = set()
+ d__ = cast(
+ "ContentStream",
+ self._reference_clone(
+ self.__class__(None, None), pdf_dest, force_duplicate
+ ),
+ )
+ if ignore_fields is None:
+ ignore_fields = []
+ d__._clone(self, pdf_dest, force_duplicate, ignore_fields, visited)
+ return d__
+
+ def _clone(
+ self,
+ src: DictionaryObject,
+ pdf_dest: PdfWriterProtocol,
+ force_duplicate: bool,
+ ignore_fields: Optional[Sequence[Union[str, int]]],
+ visited: set[tuple[int, int]],
+ ) -> None:
+ """
+ Update the object from src.
+
+ Args:
+ src:
+ pdf_dest:
+ force_duplicate:
+ ignore_fields:
+
+ """
+ src_cs = cast("ContentStream", src)
+ super().set_data(src_cs._data)
+ self.pdf = pdf_dest
+ self._operations = list(src_cs._operations)
+ self.forced_encoding = src_cs.forced_encoding
+ # no need to call DictionaryObjection or anything
+ # like super(DictionaryObject,self)._clone(src, pdf_dest, force_duplicate, ignore_fields, visited)
+
+ def _parse_content_stream(self, stream: StreamType) -> None:
+ # 7.8.2 Content Streams
+ stream.seek(0, 0)
+ operands: list[Union[int, str, PdfObject]] = []
+ while True:
+ peek = read_non_whitespace(stream)
+ if peek in (b"", 0):
+ break
+ stream.seek(-1, 1)
+ if peek.isalpha() or peek in (b"'", b'"'):
+ operator = read_until_regex(stream, NameObject.delimiter_pattern)
+ if operator == b"BI":
+ # begin inline image - a completely different parsing
+ # mechanism is required, of course... thanks buddy...
+ assert operands == []
+ ii = self._read_inline_image(stream)
+ self._operations.append((ii, b"INLINE IMAGE"))
+ else:
+ self._operations.append((operands, operator))
+ operands = []
+ elif peek == b"%":
+ # If we encounter a comment in the content stream, we have to
+ # handle it here. Typically, read_object will handle
+ # encountering a comment -- but read_object assumes that
+ # following the comment must be the object we're trying to
+ # read. In this case, it could be an operator instead.
+ while peek not in (b"\r", b"\n", b""):
+ peek = stream.read(1)
+ else:
+ operands.append(read_object(stream, None, self.forced_encoding))
+
+ def _read_inline_image(self, stream: StreamType) -> dict[str, Any]:
+ # begin reading just after the "BI" - begin image
+ # first read the dictionary of settings.
+ settings = DictionaryObject()
+ while True:
+ tok = read_non_whitespace(stream)
+ stream.seek(-1, 1)
+ if tok == b"I":
+ # "ID" - begin of image data
+ break
+ key = read_object(stream, self.pdf)
+ tok = read_non_whitespace(stream)
+ stream.seek(-1, 1)
+ value = read_object(stream, self.pdf)
+ settings[key] = value
+ # left at beginning of ID
+ tmp = stream.read(3)
+ assert tmp[:2] == b"ID"
+ filtr = settings.get("/F", settings.get("/Filter", "not set"))
+ savpos = stream.tell()
+ if isinstance(filtr, list):
+ filtr = filtr[0] # used forencoding
+ if "AHx" in filtr or "ASCIIHexDecode" in filtr:
+ data = extract_inline__ascii_hex_decode(stream)
+ elif "A85" in filtr or "ASCII85Decode" in filtr:
+ data = extract_inline__ascii85_decode(stream)
+ elif "RL" in filtr or "RunLengthDecode" in filtr:
+ data = extract_inline__run_length_decode(stream)
+ elif "DCT" in filtr or "DCTDecode" in filtr:
+ data = extract_inline__dct_decode(stream)
+ elif filtr == "not set":
+ cs = settings.get("/CS", "")
+ if isinstance(cs, list):
+ cs = cs[0]
+ if "RGB" in cs:
+ lcs = 3
+ elif "CMYK" in cs:
+ lcs = 4
+ else:
+ bits = settings.get(
+ "/BPC",
+ 8 if cs in {"/I", "/G", "/Indexed", "/DeviceGray"} else -1,
+ )
+ if bits > 0:
+ lcs = bits / 8.0
+ else:
+ data = extract_inline_default(stream)
+ lcs = -1
+ if lcs > 0:
+ data = stream.read(
+ ceil(cast(int, settings["/W"]) * lcs) * cast(int, settings["/H"])
+ )
+ # Move to the `EI` if possible.
+ ei = read_non_whitespace(stream)
+ stream.seek(-1, 1)
+ else:
+ data = extract_inline_default(stream)
+
+ ei = stream.read(3)
+ stream.seek(-1, 1)
+ if ei[:2] != b"EI" or ei[2:3] not in WHITESPACES:
+ # Deal with wrong/missing `EI` tags. Example: Wrong dimensions specified above.
+ stream.seek(savpos, 0)
+ data = extract_inline_default(stream)
+ ei = stream.read(3)
+ stream.seek(-1, 1)
+ if ei[:2] != b"EI" or ei[2:3] not in WHITESPACES: # pragma: no cover
+ # Check the same condition again. This should never fail as
+ # edge cases are covered by `extract_inline_default` above,
+ # but check this ot make sure that we are behind the `EI` afterwards.
+ raise PdfStreamError(
+ f"Could not extract inline image, even using fallback. Expected 'EI', got {ei!r}"
+ )
+ return {"settings": settings, "data": data}
+
+ # This overrides the parent method
+ def get_data(self) -> bytes:
+ if not self._data:
+ new_data = BytesIO()
+ for operands, operator in self._operations:
+ if operator == b"INLINE IMAGE":
+ new_data.write(b"BI")
+ dict_text = BytesIO()
+ operands["settings"].write_to_stream(dict_text)
+ new_data.write(dict_text.getvalue()[2:-2])
+ new_data.write(b"ID ")
+ new_data.write(operands["data"])
+ new_data.write(b"EI")
+ else:
+ for op in operands:
+ op.write_to_stream(new_data)
+ new_data.write(b" ")
+ new_data.write(operator)
+ new_data.write(b"\n")
+ self._data = new_data.getvalue()
+ return self._data
+
+ # This overrides the parent method
+ def set_data(self, data: bytes) -> None:
+ super().set_data(data)
+ self._operations = []
+
+ @property
+ def operations(self) -> list[tuple[Any, bytes]]:
+ if not self._operations and self._data:
+ self._parse_content_stream(BytesIO(self._data))
+ self._data = b""
+ return self._operations
+
+ @operations.setter
+ def operations(self, operations: list[tuple[Any, bytes]]) -> None:
+ self._operations = operations
+ self._data = b""
+
+ def isolate_graphics_state(self) -> None:
+ if self._operations:
+ self._operations.insert(0, ([], b"q"))
+ self._operations.append(([], b"Q"))
+ elif self._data:
+ self._data = b"q\n" + self._data + b"\nQ\n"
+
+ # This overrides the parent method
+ def write_to_stream(
+ self, stream: StreamType, encryption_key: Union[None, str, bytes] = None
+ ) -> None:
+ if not self._data and self._operations:
+ self.get_data() # this ensures ._data is rebuilt
+ super().write_to_stream(stream, encryption_key)
+
+
+def read_object(
+ stream: StreamType,
+ pdf: Optional[PdfReaderProtocol],
+ forced_encoding: Union[None, str, list[str], dict[int, str]] = None,
+) -> Union[PdfObject, int, str, ContentStream]:
+ tok = stream.read(1)
+ stream.seek(-1, 1) # reset to start
+ if tok == b"/":
+ return NameObject.read_from_stream(stream, pdf)
+ if tok == b"<":
+ # hexadecimal string OR dictionary
+ peek = stream.read(2)
+ stream.seek(-2, 1) # reset to start
+ if peek == b"<<":
+ return DictionaryObject.read_from_stream(stream, pdf, forced_encoding)
+ return read_hex_string_from_stream(stream, forced_encoding)
+ if tok == b"[":
+ return ArrayObject.read_from_stream(stream, pdf, forced_encoding)
+ if tok in (b"t", b"f"):
+ return BooleanObject.read_from_stream(stream)
+ if tok == b"(":
+ return read_string_from_stream(stream, forced_encoding)
+ if tok == b"e" and stream.read(6) == b"endobj":
+ return NullObject()
+ if tok == b"n":
+ return NullObject.read_from_stream(stream)
+ if tok == b"%":
+ # comment
+ skip_over_comment(stream)
+ tok = read_non_whitespace(stream)
+ stream.seek(-1, 1)
+ return read_object(stream, pdf, forced_encoding)
+ if tok in b"0123456789+-.":
+ # number object OR indirect reference
+ peek = stream.read(20)
+ stream.seek(-len(peek), 1) # reset to start
+ if IndirectPattern.match(peek) is not None:
+ assert pdf is not None, "mypy"
+ return IndirectObject.read_from_stream(stream, pdf)
+ return NumberObject.read_from_stream(stream)
+ pos = stream.tell()
+ stream.seek(-20, 1)
+ stream_extract = stream.read(80)
+ stream.seek(pos)
+ read_until_whitespace(stream)
+ raise PdfReadError(
+ f"Invalid Elementary Object starting with {tok!r} @{pos}: {stream_extract!r}"
+ )
+
+
+class Field(TreeObject):
+ """
+ A class representing a field dictionary.
+
+ This class is accessed through
+ :meth:`get_fields()`
+ """
+
+ def __init__(self, data: DictionaryObject) -> None:
+ DictionaryObject.__init__(self)
+ field_attributes = (
+ FieldDictionaryAttributes.attributes()
+ + CheckboxRadioButtonAttributes.attributes()
+ )
+ self.indirect_reference = data.indirect_reference
+ for attr in field_attributes:
+ try:
+ self[NameObject(attr)] = data[attr]
+ except KeyError:
+ pass
+ if isinstance(self.get("/V"), EncodedStreamObject):
+ d = cast(EncodedStreamObject, self[NameObject("/V")]).get_data()
+ if isinstance(d, bytes):
+ d_str = d.decode()
+ elif d is None:
+ d_str = ""
+ else:
+ raise Exception("Should never happen")
+ self[NameObject("/V")] = TextStringObject(d_str)
+
+ # TABLE 8.69 Entries common to all field dictionaries
+ @property
+ def field_type(self) -> Optional[NameObject]:
+ """Read-only property accessing the type of this field."""
+ return self.get(FieldDictionaryAttributes.FT)
+
+ @property
+ def parent(self) -> Optional[DictionaryObject]:
+ """Read-only property accessing the parent of this field."""
+ return self.get(FieldDictionaryAttributes.Parent)
+
+ @property
+ def kids(self) -> Optional["ArrayObject"]:
+ """Read-only property accessing the kids of this field."""
+ return self.get(FieldDictionaryAttributes.Kids)
+
+ @property
+ def name(self) -> Optional[str]:
+ """Read-only property accessing the name of this field."""
+ return self.get(FieldDictionaryAttributes.T)
+
+ @property
+ def alternate_name(self) -> Optional[str]:
+ """Read-only property accessing the alternate name of this field."""
+ return self.get(FieldDictionaryAttributes.TU)
+
+ @property
+ def mapping_name(self) -> Optional[str]:
+ """
+ Read-only property accessing the mapping name of this field.
+
+ This name is used by pypdf as a key in the dictionary returned by
+ :meth:`get_fields()`
+ """
+ return self.get(FieldDictionaryAttributes.TM)
+
+ @property
+ def flags(self) -> Optional[int]:
+ """
+ Read-only property accessing the field flags, specifying various
+ characteristics of the field (see Table 8.70 of the PDF 1.7 reference).
+ """
+ return self.get(FieldDictionaryAttributes.Ff)
+
+ @property
+ def value(self) -> Optional[Any]:
+ """
+ Read-only property accessing the value of this field.
+
+ Format varies based on field type.
+ """
+ return self.get(FieldDictionaryAttributes.V)
+
+ @property
+ def default_value(self) -> Optional[Any]:
+ """Read-only property accessing the default value of this field."""
+ return self.get(FieldDictionaryAttributes.DV)
+
+ @property
+ def additional_actions(self) -> Optional[DictionaryObject]:
+ """
+ Read-only property accessing the additional actions dictionary.
+
+ This dictionary defines the field's behavior in response to trigger
+ events. See Section 8.5.2 of the PDF 1.7 reference.
+ """
+ return self.get(FieldDictionaryAttributes.AA)
+
+
+class Destination(TreeObject):
+ """
+ A class representing a destination within a PDF file.
+
+ See section 12.3.2 of the PDF 2.0 reference.
+
+ Args:
+ title: Title of this destination.
+ page: Reference to the page of this destination. Should
+ be an instance of :class:`IndirectObject`.
+ fit: How the destination is displayed.
+
+ Raises:
+ PdfReadError: If destination type is invalid.
+
+ """
+
+ node: Optional[
+ DictionaryObject
+ ] = None # node provide access to the original Object
+
+ def __init__(
+ self,
+ title: Union[str, bytes],
+ page: Union[NumberObject, IndirectObject, NullObject, DictionaryObject],
+ fit: Fit,
+ ) -> None:
+ self._filtered_children: list[Any] = [] # used in PdfWriter
+
+ typ = fit.fit_type
+ args = fit.fit_args
+
+ DictionaryObject.__init__(self)
+ self[NameObject("/Title")] = TextStringObject(title)
+ self[NameObject("/Page")] = page
+ self[NameObject("/Type")] = typ
+
+ # from table 8.2 of the PDF 1.7 reference.
+ if typ == "/XYZ":
+ if len(args) < 1: # left is missing : should never occur
+ args.append(NumberObject(0.0))
+ if len(args) < 2: # top is missing
+ args.append(NumberObject(0.0))
+ if len(args) < 3: # zoom is missing
+ args.append(NumberObject(0.0))
+ (
+ self[NameObject(TA.LEFT)],
+ self[NameObject(TA.TOP)],
+ self[NameObject("/Zoom")],
+ ) = args
+ elif len(args) == 0:
+ pass
+ elif typ == TF.FIT_R:
+ (
+ self[NameObject(TA.LEFT)],
+ self[NameObject(TA.BOTTOM)],
+ self[NameObject(TA.RIGHT)],
+ self[NameObject(TA.TOP)],
+ ) = args
+ elif typ in [TF.FIT_H, TF.FIT_BH]:
+ try: # Prefer to be more robust not only to null parameters
+ (self[NameObject(TA.TOP)],) = args
+ except Exception:
+ (self[NameObject(TA.TOP)],) = (NullObject(),)
+ elif typ in [TF.FIT_V, TF.FIT_BV]:
+ try: # Prefer to be more robust not only to null parameters
+ (self[NameObject(TA.LEFT)],) = args
+ except Exception:
+ (self[NameObject(TA.LEFT)],) = (NullObject(),)
+ elif typ in [TF.FIT, TF.FIT_B]:
+ pass
+ else:
+ raise PdfReadError(f"Unknown Destination Type: {typ!r}")
+
+ @property
+ def dest_array(self) -> "ArrayObject":
+ return ArrayObject(
+ [self.raw_get("/Page"), self["/Type"]]
+ + [
+ self[x]
+ for x in ["/Left", "/Bottom", "/Right", "/Top", "/Zoom"]
+ if x in self
+ ]
+ )
+
+ def write_to_stream(
+ self, stream: StreamType, encryption_key: Union[None, str, bytes] = None
+ ) -> None:
+ if encryption_key is not None: # deprecated
+ deprecation_no_replacement(
+ "the encryption_key parameter of write_to_stream", "5.0.0"
+ )
+ stream.write(b"<<\n")
+ key = NameObject("/D")
+ key.write_to_stream(stream)
+ stream.write(b" ")
+ value = self.dest_array
+ value.write_to_stream(stream)
+
+ key = NameObject("/S")
+ key.write_to_stream(stream)
+ stream.write(b" ")
+ value_s = NameObject("/GoTo")
+ value_s.write_to_stream(stream)
+
+ stream.write(b"\n")
+ stream.write(b">>")
+
+ @property
+ def title(self) -> Optional[str]:
+ """Read-only property accessing the destination title."""
+ return self.get("/Title")
+
+ @property
+ def page(self) -> Optional[IndirectObject]:
+ """Read-only property accessing the IndirectObject of the destination page."""
+ return self.get("/Page")
+
+ @property
+ def typ(self) -> Optional[str]:
+ """Read-only property accessing the destination type."""
+ return self.get("/Type")
+
+ @property
+ def zoom(self) -> Optional[int]:
+ """Read-only property accessing the zoom factor."""
+ return self.get("/Zoom", None)
+
+ @property
+ def left(self) -> Optional[FloatObject]:
+ """Read-only property accessing the left horizontal coordinate."""
+ return self.get("/Left", None)
+
+ @property
+ def right(self) -> Optional[FloatObject]:
+ """Read-only property accessing the right horizontal coordinate."""
+ return self.get("/Right", None)
+
+ @property
+ def top(self) -> Optional[FloatObject]:
+ """Read-only property accessing the top vertical coordinate."""
+ return self.get("/Top", None)
+
+ @property
+ def bottom(self) -> Optional[FloatObject]:
+ """Read-only property accessing the bottom vertical coordinate."""
+ return self.get("/Bottom", None)
+
+ @property
+ def color(self) -> Optional["ArrayObject"]:
+ """Read-only property accessing the color in (R, G, B) with values 0.0-1.0."""
+ return self.get(
+ "/C", ArrayObject([FloatObject(0), FloatObject(0), FloatObject(0)])
+ )
+
+ @property
+ def font_format(self) -> Optional[OutlineFontFlag]:
+ """
+ Read-only property accessing the font type.
+
+ 1=italic, 2=bold, 3=both
+ """
+ return self.get("/F", 0)
+
+ @property
+ def outline_count(self) -> Optional[int]:
+ """
+ Read-only property accessing the outline count.
+
+ positive = expanded
+ negative = collapsed
+ absolute value = number of visible descendants at all levels
+ """
+ return self.get("/Count", None)
diff --git a/venv/lib/python3.12/site-packages/pypdf/generic/_files.py b/venv/lib/python3.12/site-packages/pypdf/generic/_files.py
new file mode 100644
index 0000000..f29fa77
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/generic/_files.py
@@ -0,0 +1,401 @@
+from __future__ import annotations
+
+import bisect
+from functools import cached_property
+from typing import TYPE_CHECKING, cast
+
+from pypdf._utils import format_iso8824_date, parse_iso8824_date
+from pypdf.constants import CatalogAttributes as CA
+from pypdf.constants import FileSpecificationDictionaryEntries
+from pypdf.constants import PageAttributes as PG
+from pypdf.errors import PdfReadError, PyPdfError
+from pypdf.generic import (
+ ArrayObject,
+ ByteStringObject,
+ DecodedStreamObject,
+ DictionaryObject,
+ NameObject,
+ NullObject,
+ NumberObject,
+ StreamObject,
+ TextStringObject,
+ is_null_or_none,
+)
+
+if TYPE_CHECKING:
+ import datetime
+ from collections.abc import Generator
+
+ from pypdf._writer import PdfWriter
+
+
+class EmbeddedFile:
+ """
+ Container holding the information on an embedded file.
+
+ Attributes are evaluated lazily if possible.
+
+ Further information on embedded files can be found in section 7.11 of the PDF 2.0 specification.
+ """
+ def __init__(self, name: str, pdf_object: DictionaryObject, parent: ArrayObject | None = None) -> None:
+ """
+ Args:
+ name: The (primary) name as provided in the name tree.
+ pdf_object: The corresponding PDF object to allow retrieving further data.
+ parent: The parent list.
+ """
+ self._name = name
+ self.pdf_object = pdf_object
+ self._parent = parent
+
+ @property
+ def name(self) -> str:
+ """The (primary) name of the embedded file as provided in the name tree."""
+ return self._name
+
+ @classmethod
+ def _create_new(cls, writer: PdfWriter, name: str, content: str | bytes) -> EmbeddedFile:
+ """
+ Create a new embedded file and add it to the PdfWriter.
+
+ Args:
+ writer: The PdfWriter instance to add the embedded file to.
+ name: The filename to display.
+ content: The data in the file.
+
+ Returns:
+ EmbeddedFile instance for the newly created embedded file.
+ """
+ # Convert string content to bytes if needed
+ if isinstance(content, str):
+ content = content.encode("latin-1")
+
+ # Create the file entry (the actual embedded file stream)
+ file_entry = DecodedStreamObject()
+ file_entry.set_data(content)
+ file_entry.update({NameObject(PG.TYPE): NameObject("/EmbeddedFile")})
+
+ # Create the /EF entry
+ ef_entry = DictionaryObject()
+ ef_entry.update({NameObject("/F"): writer._add_object(file_entry)})
+
+ # Create the filespec dictionary
+ from pypdf.generic import create_string_object # noqa: PLC0415
+ filespec = DictionaryObject()
+ filespec_reference = writer._add_object(filespec)
+ name_object = cast(TextStringObject, create_string_object(name))
+ filespec.update(
+ {
+ NameObject(PG.TYPE): NameObject("/Filespec"),
+ NameObject(FileSpecificationDictionaryEntries.F): name_object,
+ NameObject(FileSpecificationDictionaryEntries.EF): ef_entry,
+ }
+ )
+
+ # Add the name and filespec to the names array.
+ # We use the inverse order for insertion, as this allows us to re-use the
+ # same index.
+ names_array = cls._get_names_array(writer)
+ insertion_index = cls._get_insertion_index(names_array, name_object)
+ names_array.insert(insertion_index, filespec_reference)
+ names_array.insert(insertion_index, name_object)
+
+ # Return an EmbeddedFile instance
+ return cls(name=name, pdf_object=filespec, parent=names_array)
+
+ @classmethod
+ def _get_names_array(cls, writer: PdfWriter) -> ArrayObject:
+ """Get the names array for embedded files, possibly creating and flattening it."""
+ if CA.NAMES not in writer.root_object:
+ # Add the /Names entry to the catalog.
+ writer.root_object[NameObject(CA.NAMES)] = writer._add_object(DictionaryObject())
+
+ names_dict = cast(DictionaryObject, writer.root_object[CA.NAMES])
+ if "/EmbeddedFiles" not in names_dict:
+ # We do not yet have an entry for embedded files. Create and return it.
+ names = ArrayObject()
+ embedded_files_names_dictionary = DictionaryObject(
+ {NameObject(CA.NAMES): names}
+ )
+ names_dict[NameObject("/EmbeddedFiles")] = writer._add_object(embedded_files_names_dictionary)
+ return names
+
+ # We have an existing embedded files entry.
+ embedded_files_names_tree = cast(DictionaryObject, names_dict["/EmbeddedFiles"])
+ if "/Names" in embedded_files_names_tree:
+ # Simple case: We already have a flat list.
+ return cast(ArrayObject, embedded_files_names_tree[NameObject(CA.NAMES)])
+ if "/Kids" not in embedded_files_names_tree:
+ # Invalid case: This is no name tree.
+ raise PdfReadError("Got neither Names nor Kids in embedded files tree.")
+
+ # Complex case: Convert a /Kids-based name tree to a /Names-based one.
+ # /Name-based ones are much easier to handle and allow us to simplify the
+ # actual insertion logic by only having to consider one case.
+ names = ArrayObject()
+ kids = cast(ArrayObject, embedded_files_names_tree["/Kids"].get_object())
+ embedded_files_names_dictionary = DictionaryObject(
+ {NameObject(CA.NAMES): names}
+ )
+ names_dict[NameObject("/EmbeddedFiles")] = writer._add_object(embedded_files_names_dictionary)
+ for kid in kids:
+ # Write the flattened file entries. As we do not change the actual files,
+ # this should not have any impact on references to them.
+ # There might be further (nested) kids here.
+ # Wait for an example before evaluating an implementation.
+ for name in kid.get_object().get("/Names", []):
+ names.append(name)
+ return names
+
+ @classmethod
+ def _get_insertion_index(cls, names_array: ArrayObject, name: str) -> int:
+ keys = [names_array[i].encode("utf-8") for i in range(0, len(names_array), 2)]
+ name_bytes = name.encode("utf-8")
+
+ start = bisect.bisect_left(keys, name_bytes)
+ end = bisect.bisect_right(keys, name_bytes)
+
+ if start != end:
+ return end * 2
+ if start == 0:
+ return 0
+ if start == (key_count := len(keys)):
+ return key_count * 2
+ return end * 2
+
+ @property
+ def alternative_name(self) -> str | None:
+ """Retrieve the alternative name (file specification)."""
+ for key in [FileSpecificationDictionaryEntries.UF, FileSpecificationDictionaryEntries.F]:
+ # PDF 2.0 reference, table 43:
+ # > A PDF reader shall use the value of the UF key, when present, instead of the F key.
+ if key in self.pdf_object:
+ value = self.pdf_object[key].get_object()
+ if not is_null_or_none(value):
+ return cast(str, value)
+ return None
+
+ @alternative_name.setter
+ def alternative_name(self, value: TextStringObject | None) -> None:
+ """Set the alternative name (file specification)."""
+ if value is None:
+ if FileSpecificationDictionaryEntries.UF in self.pdf_object:
+ self.pdf_object[NameObject(FileSpecificationDictionaryEntries.UF)] = NullObject()
+ if FileSpecificationDictionaryEntries.F in self.pdf_object:
+ self.pdf_object[NameObject(FileSpecificationDictionaryEntries.F)] = NullObject()
+ else:
+ self.pdf_object[NameObject(FileSpecificationDictionaryEntries.UF)] = value
+ self.pdf_object[NameObject(FileSpecificationDictionaryEntries.F)] = value
+
+ @property
+ def description(self) -> str | None:
+ """Retrieve the description."""
+ value = self.pdf_object.get(FileSpecificationDictionaryEntries.DESC)
+ if is_null_or_none(value):
+ return None
+ return value
+
+ @description.setter
+ def description(self, value: TextStringObject | None) -> None:
+ """Set the description."""
+ if value is None:
+ self.pdf_object[NameObject(FileSpecificationDictionaryEntries.DESC)] = NullObject()
+ else:
+ self.pdf_object[NameObject(FileSpecificationDictionaryEntries.DESC)] = value
+
+ @property
+ def associated_file_relationship(self) -> str:
+ """Retrieve the relationship of the referring document to this embedded file."""
+ return self.pdf_object.get("/AFRelationship", "/Unspecified")
+
+ @associated_file_relationship.setter
+ def associated_file_relationship(self, value: NameObject) -> None:
+ """Set the relationship of the referring document to this embedded file."""
+ self.pdf_object[NameObject("/AFRelationship")] = value
+
+ @property
+ def _embedded_file(self) -> StreamObject:
+ """Retrieve the actual embedded file stream."""
+ if "/EF" not in self.pdf_object:
+ raise PdfReadError(f"/EF entry not found: {self.pdf_object}")
+ ef = cast(DictionaryObject, self.pdf_object["/EF"])
+ for key in [FileSpecificationDictionaryEntries.UF, FileSpecificationDictionaryEntries.F]:
+ if key in ef:
+ return cast(StreamObject, ef[key].get_object())
+ raise PdfReadError(f"No /(U)F key found in file dictionary: {ef}")
+
+ @property
+ def _params(self) -> DictionaryObject:
+ """Retrieve the file-specific parameters."""
+ return self._embedded_file.get("/Params", DictionaryObject()).get_object()
+
+ @cached_property
+ def _ensure_params(self) -> DictionaryObject:
+ """Ensure the /Params dictionary exists and return it."""
+ embedded_file = self._embedded_file
+ if "/Params" not in embedded_file:
+ embedded_file[NameObject("/Params")] = DictionaryObject()
+ return cast(DictionaryObject, embedded_file["/Params"])
+
+ @property
+ def subtype(self) -> str | None:
+ """Retrieve the subtype. This is a MIME media type, prefixed by a slash."""
+ value = self._embedded_file.get("/Subtype")
+ if is_null_or_none(value):
+ return None
+ return value
+
+ @subtype.setter
+ def subtype(self, value: NameObject | None) -> None:
+ """Set the subtype. This should be a MIME media type, prefixed by a slash."""
+ embedded_file = self._embedded_file
+ if value is None:
+ embedded_file[NameObject("/Subtype")] = NullObject()
+ else:
+ embedded_file[NameObject("/Subtype")] = value
+
+ @property
+ def content(self) -> bytes:
+ """Retrieve the actual file content."""
+ return self._embedded_file.get_data()
+
+ @content.setter
+ def content(self, value: str | bytes) -> None:
+ """Set the file content."""
+ if isinstance(value, str):
+ value = value.encode("latin-1")
+ self._embedded_file.set_data(value)
+
+ @property
+ def size(self) -> int | None:
+ """Retrieve the size of the uncompressed file in bytes."""
+ value = self._params.get("/Size")
+ if is_null_or_none(value):
+ return None
+ return value
+
+ @size.setter
+ def size(self, value: NumberObject | None) -> None:
+ """Set the size of the uncompressed file in bytes."""
+ params = self._ensure_params
+ if value is None:
+ params[NameObject("/Size")] = NullObject()
+ else:
+ params[NameObject("/Size")] = value
+
+ @property
+ def creation_date(self) -> datetime.datetime | None:
+ """Retrieve the file creation datetime."""
+ return parse_iso8824_date(self._params.get("/CreationDate"))
+
+ @creation_date.setter
+ def creation_date(self, value: datetime.datetime | None) -> None:
+ """Set the file creation datetime."""
+ params = self._ensure_params
+ if value is None:
+ params[NameObject("/CreationDate")] = NullObject()
+ else:
+ date_str = format_iso8824_date(value)
+ params[NameObject("/CreationDate")] = TextStringObject(date_str)
+
+ @property
+ def modification_date(self) -> datetime.datetime | None:
+ """Retrieve the datetime of the last file modification."""
+ return parse_iso8824_date(self._params.get("/ModDate"))
+
+ @modification_date.setter
+ def modification_date(self, value: datetime.datetime | None) -> None:
+ """Set the datetime of the last file modification."""
+ params = self._ensure_params
+ if value is None:
+ params[NameObject("/ModDate")] = NullObject()
+ else:
+ date_str = format_iso8824_date(value)
+ params[NameObject("/ModDate")] = TextStringObject(date_str)
+
+ @property
+ def checksum(self) -> bytes | None:
+ """Retrieve the MD5 checksum of the (uncompressed) file."""
+ value = self._params.get("/CheckSum")
+ if is_null_or_none(value):
+ return None
+ return value
+
+ @checksum.setter
+ def checksum(self, value: ByteStringObject | None) -> None:
+ """Set the MD5 checksum of the (uncompressed) file."""
+ params = self._ensure_params
+ if value is None:
+ params[NameObject("/CheckSum")] = NullObject()
+ else:
+ params[NameObject("/CheckSum")] = value
+
+ def delete(self) -> None:
+ """Delete the file from the document."""
+ if not self._parent:
+ raise PyPdfError("Parent required to delete file from document.")
+ if self.pdf_object in self._parent:
+ index = self._parent.index(self.pdf_object)
+ elif (
+ (indirect_reference := getattr(self.pdf_object, "indirect_reference", None)) is not None
+ and indirect_reference in self._parent
+ ):
+ index = self._parent.index(indirect_reference)
+ else:
+ raise PyPdfError("File not found in parent object.")
+ self._parent.pop(index) # Reference.
+ self._parent.pop(index - 1) # Name.
+ self.pdf_object = DictionaryObject() # Invalidate.
+
+ def __repr__(self) -> str:
+ return f"<{self.__class__.__name__} name={self.name!r}>"
+
+ @classmethod
+ def _load_from_names(cls, names: ArrayObject) -> Generator[EmbeddedFile]:
+ """
+ Convert the given name tree into class instances.
+
+ Args:
+ names: The name tree to load the data from.
+
+ Returns:
+ Iterable of class instances for the files found.
+ """
+ # This is a name tree of the format [name_1, reference_1, name_2, reference_2, ...]
+ for i, name in enumerate(names):
+ if not isinstance(name, str):
+ # Skip plain strings and retrieve them as `direct_name` by index.
+ file_dictionary = name.get_object()
+ direct_name = names[i - 1].get_object()
+ yield EmbeddedFile(name=direct_name, pdf_object=file_dictionary, parent=names)
+
+ @classmethod
+ def _load(cls, catalog: DictionaryObject) -> Generator[EmbeddedFile]:
+ """
+ Load the embedded files for the given document catalog.
+
+ This method and its signature are considered internal API and thus not exposed publicly for now.
+
+ Args:
+ catalog: The document catalog to load from.
+
+ Returns:
+ Iterable of class instances for the files found.
+ """
+ try:
+ container = cast(
+ DictionaryObject,
+ cast(DictionaryObject, catalog["/Names"])["/EmbeddedFiles"],
+ )
+ except KeyError:
+ return
+
+ if "/Kids" in container:
+ for kid in cast(ArrayObject, container["/Kids"].get_object()):
+ # There might be further (nested) kids here.
+ # Wait for an example before evaluating an implementation.
+ kid = kid.get_object()
+ if "/Names" in kid:
+ yield from cls._load_from_names(cast(ArrayObject, kid["/Names"]))
+ if "/Names" in container:
+ yield from cls._load_from_names(cast(ArrayObject, container["/Names"]))
diff --git a/venv/lib/python3.12/site-packages/pypdf/generic/_fit.py b/venv/lib/python3.12/site-packages/pypdf/generic/_fit.py
new file mode 100644
index 0000000..293066a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/generic/_fit.py
@@ -0,0 +1,174 @@
+from typing import Any, Optional, Union
+
+from ._base import is_null_or_none
+
+
+class Fit:
+ def __init__(
+ self, fit_type: str, fit_args: tuple[Union[None, float, Any], ...] = ()
+ ) -> None:
+ from ._base import FloatObject, NameObject, NullObject, NumberObject # noqa: PLC0415
+
+ self.fit_type = NameObject(fit_type)
+ self.fit_args: list[Union[NullObject, FloatObject, NumberObject]] = [
+ NullObject() if is_null_or_none(a) else FloatObject(a) for a in fit_args
+ ]
+
+ @classmethod
+ def xyz(
+ cls,
+ left: Optional[float] = None,
+ top: Optional[float] = None,
+ zoom: Optional[float] = None,
+ ) -> "Fit":
+ """
+ Display the page designated by page, with the coordinates (left, top)
+ positioned at the upper-left corner of the window and the contents
+ of the page magnified by the factor zoom.
+
+ A null value for any of the parameters left, top, or zoom specifies
+ that the current value of that parameter is to be retained unchanged.
+
+ A zoom value of 0 has the same meaning as a null value.
+
+ Args:
+ left:
+ top:
+ zoom:
+
+ Returns:
+ The created fit object.
+
+ """
+ return Fit(fit_type="/XYZ", fit_args=(left, top, zoom))
+
+ @classmethod
+ def fit(cls) -> "Fit":
+ """
+ Display the page designated by page, with its contents magnified just
+ enough to fit the entire page within the window both horizontally and
+ vertically.
+
+ If the required horizontal and vertical magnification factors are
+ different, use the smaller of the two, centering the page within the
+ window in the other dimension.
+ """
+ return Fit(fit_type="/Fit")
+
+ @classmethod
+ def fit_horizontally(cls, top: Optional[float] = None) -> "Fit":
+ """
+ Display the page designated by page, with the vertical coordinate top
+ positioned at the top edge of the window and the contents of the page
+ magnified just enough to fit the entire width of the page within the
+ window.
+
+ A null value for ``top`` specifies that the current value of that
+ parameter is to be retained unchanged.
+
+ Args:
+ top:
+
+ Returns:
+ The created fit object.
+
+ """
+ return Fit(fit_type="/FitH", fit_args=(top,))
+
+ @classmethod
+ def fit_vertically(cls, left: Optional[float] = None) -> "Fit":
+ return Fit(fit_type="/FitV", fit_args=(left,))
+
+ @classmethod
+ def fit_rectangle(
+ cls,
+ left: Optional[float] = None,
+ bottom: Optional[float] = None,
+ right: Optional[float] = None,
+ top: Optional[float] = None,
+ ) -> "Fit":
+ """
+ Display the page designated by page, with its contents magnified
+ just enough to fit the rectangle specified by the coordinates
+ left, bottom, right, and top entirely within the window
+ both horizontally and vertically.
+
+ If the required horizontal and vertical magnification factors are
+ different, use the smaller of the two, centering the rectangle within
+ the window in the other dimension.
+
+ A null value for any of the parameters may result in unpredictable
+ behavior.
+
+ Args:
+ left:
+ bottom:
+ right:
+ top:
+
+ Returns:
+ The created fit object.
+
+ """
+ return Fit(fit_type="/FitR", fit_args=(left, bottom, right, top))
+
+ @classmethod
+ def fit_box(cls) -> "Fit":
+ """
+ Display the page designated by page, with its contents magnified just
+ enough to fit its bounding box entirely within the window both
+ horizontally and vertically.
+
+ If the required horizontal and vertical magnification factors are
+ different, use the smaller of the two, centering the bounding box
+ within the window in the other dimension.
+ """
+ return Fit(fit_type="/FitB")
+
+ @classmethod
+ def fit_box_horizontally(cls, top: Optional[float] = None) -> "Fit":
+ """
+ Display the page designated by page, with the vertical coordinate top
+ positioned at the top edge of the window and the contents of the page
+ magnified just enough to fit the entire width of its bounding box
+ within the window.
+
+ A null value for top specifies that the current value of that parameter
+ is to be retained unchanged.
+
+ Args:
+ top:
+
+ Returns:
+ The created fit object.
+
+ """
+ return Fit(fit_type="/FitBH", fit_args=(top,))
+
+ @classmethod
+ def fit_box_vertically(cls, left: Optional[float] = None) -> "Fit":
+ """
+ Display the page designated by page, with the horizontal coordinate
+ left positioned at the left edge of the window and the contents of the
+ page magnified just enough to fit the entire height of its bounding box
+ within the window.
+
+ A null value for left specifies that the current value of that
+ parameter is to be retained unchanged.
+
+ Args:
+ left:
+
+ Returns:
+ The created fit object.
+
+ """
+ return Fit(fit_type="/FitBV", fit_args=(left,))
+
+ def __str__(self) -> str:
+ if not self.fit_args:
+ return f"Fit({self.fit_type})"
+ return f"Fit({self.fit_type}, {self.fit_args})"
+
+
+DEFAULT_FIT = Fit.fit()
diff --git a/venv/lib/python3.12/site-packages/pypdf/generic/_image_inline.py b/venv/lib/python3.12/site-packages/pypdf/generic/_image_inline.py
new file mode 100644
index 0000000..d187693
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/generic/_image_inline.py
@@ -0,0 +1,314 @@
+# Copyright (c) 2024, pypdf contributors
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+
+import logging
+from io import BytesIO
+from typing import IO
+
+from .._utils import (
+ WHITESPACES,
+ WHITESPACES_AS_BYTES,
+ StreamType,
+ logger_warning,
+ read_non_whitespace,
+)
+from ..errors import PdfReadError
+
+logger = logging.getLogger(__name__)
+
+# An inline image should be used only for small images (4096 bytes or less),
+# but allow twice this for cases where this has been exceeded.
+BUFFER_SIZE = 8192
+
+
+def _check_end_image_marker(stream: StreamType) -> bool:
+ ei_tok = read_non_whitespace(stream)
+ ei_tok += stream.read(2)
+ stream.seek(-3, 1)
+ return ei_tok[:2] == b"EI" and (ei_tok[2:3] == b"" or ei_tok[2:3] in WHITESPACES)
+
+
+def extract_inline__ascii_hex_decode(stream: StreamType) -> bytes:
+ """
+ Extract HexEncoded stream from inline image.
+ The stream will be moved onto the EI.
+ """
+ data_out: bytes = b""
+ # Read data until delimiter > and EI as backup.
+ while True:
+ data_buffered = read_non_whitespace(stream) + stream.read(BUFFER_SIZE)
+ if not data_buffered:
+ raise PdfReadError("Unexpected end of stream")
+ pos_tok = data_buffered.find(b">")
+ if pos_tok >= 0: # found >
+ data_out += data_buffered[: pos_tok + 1]
+ stream.seek(-len(data_buffered) + pos_tok + 1, 1)
+ break
+ pos_ei = data_buffered.find(b"EI")
+ if pos_ei >= 0: # found EI
+ stream.seek(-len(data_buffered) + pos_ei - 1, 1)
+ c = stream.read(1)
+ while c in WHITESPACES:
+ stream.seek(-2, 1)
+ c = stream.read(1)
+ pos_ei -= 1
+ data_out += data_buffered[:pos_ei]
+ break
+ if len(data_buffered) == 2:
+ data_out += data_buffered
+ raise PdfReadError("Unexpected end of stream")
+ # Neither > nor EI found
+ data_out += data_buffered[:-2]
+ stream.seek(-2, 1)
+
+ if not _check_end_image_marker(stream):
+ raise PdfReadError("EI stream not found")
+ return data_out
+
+
+def extract_inline__ascii85_decode(stream: StreamType) -> bytes:
+ """
+ Extract A85 stream from inline image.
+ The stream will be moved onto the EI.
+ """
+ data_out: bytes = b""
+ # Read data until delimiter ~>
+ while True:
+ data_buffered = read_non_whitespace(stream) + stream.read(BUFFER_SIZE)
+ if not data_buffered:
+ raise PdfReadError("Unexpected end of stream")
+ pos_tok = data_buffered.find(b"~>")
+ if pos_tok >= 0: # found!
+ data_out += data_buffered[: pos_tok + 2]
+ stream.seek(-len(data_buffered) + pos_tok + 2, 1)
+ break
+ if len(data_buffered) == 2: # end of buffer
+ data_out += data_buffered
+ raise PdfReadError("Unexpected end of stream")
+ data_out += data_buffered[
+ :-2
+ ] # back by one char in case of in the middle of ~>
+ stream.seek(-2, 1)
+
+ if not _check_end_image_marker(stream):
+ raise PdfReadError("EI stream not found")
+ return data_out
+
+
+def extract_inline__run_length_decode(stream: StreamType) -> bytes:
+ """
+ Extract RL (RunLengthDecode) stream from inline image.
+ The stream will be moved onto the EI.
+ """
+ data_out: bytes = b""
+ # Read data until delimiter 128
+ while True:
+ data_buffered = stream.read(BUFFER_SIZE)
+ if not data_buffered:
+ raise PdfReadError("Unexpected end of stream")
+ pos_tok = data_buffered.find(b"\x80")
+ if pos_tok >= 0: # found
+ # Ideally, we could just use plain run-length decoding here, where 80_16 = 128_10
+ # marks the EOD. But there apparently are cases like in issue #3517, where we have
+ # an inline image with up to 51 EOD markers. In these cases, be resilient here and
+ # use the default `EI` marker detection instead. Please note that this fallback
+ # still omits special `EI` handling within the stream, but for now assume that having
+ # both of these cases occur at the same time is very unlikely (and the image stream
+ # is broken anyway).
+ # For now, do not skip over more than one whitespace character.
+ after_token = data_buffered[pos_tok + 1 : pos_tok + 4]
+ if after_token.startswith(b"EI") or after_token.endswith(b"EI"):
+ data_out += data_buffered[: pos_tok + 1]
+ stream.seek(-len(data_buffered) + pos_tok + 1, 1)
+ else:
+ logger_warning("Early EOD in RunLengthDecode of inline image, using fallback.", __name__)
+ ei_marker = data_buffered.find(b"EI")
+ if ei_marker > 0:
+ data_out += data_buffered[: ei_marker]
+ stream.seek(-len(data_buffered) + ei_marker - 1, 1)
+ break
+ data_out += data_buffered
+
+ if not _check_end_image_marker(stream):
+ raise PdfReadError("EI stream not found")
+ return data_out
+
+
+def extract_inline__dct_decode(stream: StreamType) -> bytes:
+ """
+ Extract DCT (JPEG) stream from inline image.
+ The stream will be moved onto the EI.
+ """
+ def read(length: int) -> bytes:
+ # If 0 bytes are returned, and *size* was not 0, this indicates end of file.
+ # If the object is in non-blocking mode and no bytes are available, `None` is returned.
+ _result = stream.read(length)
+ if _result is None or len(_result) != length:
+ raise PdfReadError("Unexpected end of stream")
+ return _result
+
+ data_out: bytes = b""
+ # Read Blocks of data (ID/Size/data) up to ID=FF/D9
+ # https://www.digicamsoft.com/itu/itu-t81-36.html
+ not_first = False
+ while True:
+ c = read(1)
+ if not_first or (c == b"\xff"):
+ data_out += c
+ if c != b"\xff":
+ continue
+ not_first = True
+ c = read(1)
+ data_out += c
+ if c == b"\xff":
+ stream.seek(-1, 1) # pragma: no cover
+ elif c == b"\x00": # stuffing
+ pass
+ elif c == b"\xd9": # end
+ break
+ elif c in (
+ b"\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc9\xca\xcb\xcc\xcd\xce\xcf"
+ b"\xda\xdb\xdc\xdd\xde\xdf"
+ b"\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xfe"
+ ):
+ c = read(2)
+ data_out += c
+ sz = c[0] * 256 + c[1]
+ data_out += read(sz - 2)
+
+ if not _check_end_image_marker(stream):
+ raise PdfReadError("EI stream not found")
+ return data_out
+
+
+def extract_inline_default(stream: StreamType) -> bytes:
+ """Legacy method, used by default"""
+ stream_out = BytesIO()
+ # Read the inline image, while checking for EI (End Image) operator.
+ while True:
+ data_buffered = stream.read(BUFFER_SIZE)
+ if not data_buffered:
+ raise PdfReadError("Unexpected end of stream")
+ pos_ei = data_buffered.find(
+ b"E"
+ ) # We can not look straight for "EI" because it may not have been loaded in the buffer
+
+ if pos_ei == -1:
+ stream_out.write(data_buffered)
+ else:
+ # Write out everything including E (the one from EI to be removed)
+ stream_out.write(data_buffered[0 : pos_ei + 1])
+ sav_pos_ei = stream_out.tell() - 1
+ # Seek back in the stream to read the E next
+ stream.seek(pos_ei + 1 - len(data_buffered), 1)
+ saved_pos = stream.tell()
+ # Check for End Image
+ tok2 = stream.read(1) # I of "EI"
+ if tok2 != b"I":
+ stream.seek(saved_pos, 0)
+ continue
+ tok3 = stream.read(1) # possible space after "EI"
+ if tok3 not in WHITESPACES:
+ stream.seek(saved_pos, 0)
+ continue
+ while tok3 in WHITESPACES:
+ tok3 = stream.read(1)
+ if data_buffered[pos_ei - 1 : pos_ei] not in WHITESPACES and tok3 not in {
+ b"Q",
+ b"E",
+ }: # for Q or EMC
+ stream.seek(saved_pos, 0)
+ continue
+ if is_followed_by_binary_data(stream):
+ # Inline image contains `EI ` sequence usually marking the end of it, but
+ # is followed by binary data which does not make sense for the actual end.
+ stream.seek(saved_pos, 0)
+ continue
+ # Data contains [\s]EI[\s](Q|EMC): 4 chars are sufficient
+ # remove E(I) wrongly inserted earlier
+ stream.seek(saved_pos - 1, 0)
+ stream_out.truncate(sav_pos_ei)
+ break
+
+ return stream_out.getvalue()
+
+
+def is_followed_by_binary_data(stream: IO[bytes], length: int = 10) -> bool:
+ """
+ Check if the next bytes of the stream look like binary image data or regular page content.
+
+ This is just some heuristics due to the PDF specification being too imprecise about
+ inline images containing the `EI` marker which would end an image. Starting with PDF 2.0,
+ we finally get a mandatory length field, but with (proper) PDF 2.0 support being very limited
+ everywhere, we should not expect to be able to remove such hacks in the near future - especially
+ considering legacy documents as well.
+
+ The actual implementation draws some inspiration from
+ https://github.com/itext/itext-java/blob/9.1.0/kernel/src/main/java/com/itextpdf/kernel/pdf/canvas/parser/util/InlineImageParsingUtils.java
+ """
+ position = stream.tell()
+ data = stream.read(length)
+ stream.seek(position)
+ if not data:
+ return False
+ operator_start = None
+ operator_end = None
+
+ for index, byte in enumerate(data):
+ if byte < 32 and byte not in WHITESPACES_AS_BYTES:
+ # This covers all characters not being displayable directly, although omitting whitespace
+ # to allow for operator detection.
+ return True
+ is_whitespace = byte in WHITESPACES_AS_BYTES
+ if operator_start is None and not is_whitespace:
+ # Interpret all other non-whitespace characters as the start of an operation.
+ operator_start = index
+ if operator_start is not None and is_whitespace:
+ # A whitespace stops an operation.
+ # Assume that having an inline image with tons of whitespace is rather unlikely.
+ operator_end = index
+ break
+
+ if operator_start is None:
+ # Inline images should not have tons of whitespaces, which would lead to no operator start.
+ return False
+ if operator_end is None:
+ # We probably are inside an operation.
+ operator_end = length
+ operator_length = operator_end - operator_start
+ operator = data[operator_start:operator_end]
+ if operator.startswith(b"/") and operator_length > 1:
+ # Name object.
+ return False
+ if operator.replace(b".", b"").isdigit():
+ # Graphics operator, for example a move. A number (integer or float).
+ return False
+ if operator_length > 3: # noqa: SIM103
+ # Usually, the operators inside a content stream should not have more than three characters,
+ # especially after an inline image.
+ return True
+ return False
diff --git a/venv/lib/python3.12/site-packages/pypdf/generic/_link.py b/venv/lib/python3.12/site-packages/pypdf/generic/_link.py
new file mode 100644
index 0000000..20a168b
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/generic/_link.py
@@ -0,0 +1,118 @@
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+
+
+# This module contains code used by _writer.py to track links in pages
+# being added to the writer until the links can be resolved.
+
+from typing import TYPE_CHECKING, Optional, Union, cast
+
+from . import ArrayObject, DictionaryObject, IndirectObject, PdfObject, TextStringObject
+
+if TYPE_CHECKING:
+ from .._page import PageObject
+ from .._reader import PdfReader
+ from .._writer import PdfWriter
+
+
+class NamedReferenceLink:
+ """Named reference link being preserved until we can resolve it correctly."""
+
+ def __init__(self, reference: TextStringObject, source_pdf: "PdfReader") -> None:
+ """reference: TextStringObject with named reference"""
+ self._reference = reference
+ self._source_pdf = source_pdf
+
+ def find_referenced_page(self) -> Union[IndirectObject, None]:
+ destination = self._source_pdf.named_destinations.get(str(self._reference))
+ return destination.page if destination else None
+
+ def patch_reference(self, target_pdf: "PdfWriter", new_page: IndirectObject) -> None:
+ """target_pdf: PdfWriter which the new link went into"""
+ # point named destination in new PDF to the new page
+ if str(self._reference) not in target_pdf.named_destinations:
+ target_pdf.add_named_destination(str(self._reference), new_page.page_number)
+
+
+class DirectReferenceLink:
+ """Direct reference link being preserved until we can resolve it correctly."""
+
+ def __init__(self, reference: ArrayObject) -> None:
+ """reference: an ArrayObject whose first element is the Page indirect object"""
+ self._reference = reference
+
+ def find_referenced_page(self) -> IndirectObject:
+ return self._reference[0]
+
+ def patch_reference(self, target_pdf: "PdfWriter", new_page: IndirectObject) -> None:
+ """target_pdf: PdfWriter which the new link went into"""
+ self._reference[0] = new_page
+
+
+ReferenceLink = Union[NamedReferenceLink, DirectReferenceLink]
+
+
+def extract_links(new_page: "PageObject", old_page: "PageObject") -> list[tuple[ReferenceLink, ReferenceLink]]:
+ """Extracts links from two pages on the assumption that the two pages are
+ the same. Produces one list of (new link, old link) tuples.
+ """
+ new_links = [_build_link(link, new_page) for link in new_page.get("/Annots", [])]
+ old_links = [_build_link(link, old_page) for link in old_page.get("/Annots", [])]
+
+ return [
+ (new_link, old_link) for (new_link, old_link)
+ in zip(new_links, old_links)
+ if new_link and old_link
+ ]
+
+
+def _build_link(indirect_object: IndirectObject, page: "PageObject") -> Optional[ReferenceLink]:
+ src = cast("PdfReader", page.pdf)
+ link = cast(DictionaryObject, indirect_object.get_object())
+ if (not isinstance(link, DictionaryObject)) or link.get("/Subtype") != "/Link":
+ return None
+
+ if "/A" in link:
+ action = cast(DictionaryObject, link["/A"])
+ if action.get("/S") != "/GoTo":
+ return None
+
+ if "/D" not in action:
+ return None
+ return _create_link(action["/D"], src)
+
+ if "/Dest" in link:
+ return _create_link(link["/Dest"], src)
+
+ return None # Nothing to do here
+
+
+def _create_link(reference: PdfObject, source_pdf: "PdfReader")-> Optional[ReferenceLink]:
+ if isinstance(reference, TextStringObject):
+ return NamedReferenceLink(reference, source_pdf)
+ if isinstance(reference, ArrayObject):
+ return DirectReferenceLink(reference)
+ return None
diff --git a/venv/lib/python3.12/site-packages/pypdf/generic/_outline.py b/venv/lib/python3.12/site-packages/pypdf/generic/_outline.py
new file mode 100644
index 0000000..d5d4bb1
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/generic/_outline.py
@@ -0,0 +1,33 @@
+from typing import Union
+
+from .._utils import StreamType, deprecation_no_replacement
+from ._base import NameObject
+from ._data_structures import Destination
+
+
+class OutlineItem(Destination):
+ def write_to_stream(
+ self, stream: StreamType, encryption_key: Union[None, str, bytes] = None
+ ) -> None:
+ if encryption_key is not None: # deprecated
+ deprecation_no_replacement(
+ "the encryption_key parameter of write_to_stream", "5.0.0"
+ )
+ stream.write(b"<<\n")
+ for key in [
+ NameObject(x)
+ for x in ["/Title", "/Parent", "/First", "/Last", "/Next", "/Prev"]
+ if x in self
+ ]:
+ key.write_to_stream(stream)
+ stream.write(b" ")
+ value = self.raw_get(key)
+ value.write_to_stream(stream)
+ stream.write(b"\n")
+ key = NameObject("/Dest")
+ key.write_to_stream(stream)
+ stream.write(b" ")
+ value = self.dest_array
+ value.write_to_stream(stream)
+ stream.write(b"\n")
+ stream.write(b">>")
diff --git a/venv/lib/python3.12/site-packages/pypdf/generic/_rectangle.py b/venv/lib/python3.12/site-packages/pypdf/generic/_rectangle.py
new file mode 100644
index 0000000..ba7865a
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/generic/_rectangle.py
@@ -0,0 +1,132 @@
+from typing import Any, Union
+
+from ._base import FloatObject, NumberObject
+from ._data_structures import ArrayObject
+
+
+class RectangleObject(ArrayObject):
+ """
+ This class is used to represent *page boxes* in pypdf.
+
+ These boxes include:
+
+ * :attr:`artbox `
+ * :attr:`bleedbox `
+ * :attr:`cropbox `
+ * :attr:`mediabox `
+ * :attr:`trimbox `
+ """
+
+ def __init__(
+ self, arr: Union["RectangleObject", tuple[float, float, float, float]]
+ ) -> None:
+ # must have four points
+ assert len(arr) == 4
+ # automatically convert arr[x] into NumberObject(arr[x]) if necessary
+ ArrayObject.__init__(self, [self._ensure_is_number(x) for x in arr])
+
+ def _ensure_is_number(self, value: Any) -> Union[FloatObject, NumberObject]:
+ if not isinstance(value, (FloatObject, NumberObject)):
+ value = FloatObject(value)
+ return value
+
+ def scale(self, sx: float, sy: float) -> "RectangleObject":
+ return RectangleObject(
+ (
+ float(self.left) * sx,
+ float(self.bottom) * sy,
+ float(self.right) * sx,
+ float(self.top) * sy,
+ )
+ )
+
+ def __repr__(self) -> str:
+ return f"RectangleObject({list(self)!r})"
+
+ @property
+ def left(self) -> FloatObject:
+ return self[0]
+
+ @left.setter
+ def left(self, f: float) -> None:
+ self[0] = FloatObject(f)
+
+ @property
+ def bottom(self) -> FloatObject:
+ return self[1]
+
+ @bottom.setter
+ def bottom(self, f: float) -> None:
+ self[1] = FloatObject(f)
+
+ @property
+ def right(self) -> FloatObject:
+ return self[2]
+
+ @right.setter
+ def right(self, f: float) -> None:
+ self[2] = FloatObject(f)
+
+ @property
+ def top(self) -> FloatObject:
+ return self[3]
+
+ @top.setter
+ def top(self, f: float) -> None:
+ self[3] = FloatObject(f)
+
+ @property
+ def lower_left(self) -> tuple[float, float]:
+ """
+ Property to read and modify the lower left coordinate of this box
+ in (x,y) form.
+ """
+ return self.left, self.bottom
+
+ @lower_left.setter
+ def lower_left(self, value: tuple[float, float]) -> None:
+ self[0], self[1] = (self._ensure_is_number(x) for x in value)
+
+ @property
+ def lower_right(self) -> tuple[float, float]:
+ """
+ Property to read and modify the lower right coordinate of this box
+ in (x,y) form.
+ """
+ return self.right, self.bottom
+
+ @lower_right.setter
+ def lower_right(self, value: tuple[float, float]) -> None:
+ self[2], self[1] = (self._ensure_is_number(x) for x in value)
+
+ @property
+ def upper_left(self) -> tuple[float, float]:
+ """
+ Property to read and modify the upper left coordinate of this box
+ in (x,y) form.
+ """
+ return self.left, self.top
+
+ @upper_left.setter
+ def upper_left(self, value: tuple[float, float]) -> None:
+ self[0], self[3] = (self._ensure_is_number(x) for x in value)
+
+ @property
+ def upper_right(self) -> tuple[float, float]:
+ """
+ Property to read and modify the upper right coordinate of this box
+ in (x,y) form.
+ """
+ return self.right, self.top
+
+ @upper_right.setter
+ def upper_right(self, value: tuple[float, float]) -> None:
+ self[2], self[3] = (self._ensure_is_number(x) for x in value)
+
+ @property
+ def width(self) -> float:
+ return self.right - self.left
+
+ @property
+ def height(self) -> float:
+ return self.top - self.bottom
diff --git a/venv/lib/python3.12/site-packages/pypdf/generic/_utils.py b/venv/lib/python3.12/site-packages/pypdf/generic/_utils.py
new file mode 100644
index 0000000..1b81fd2
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/generic/_utils.py
@@ -0,0 +1,208 @@
+import codecs
+from typing import Union
+
+from .._codecs import _pdfdoc_encoding
+from .._utils import StreamType, logger_warning, read_non_whitespace
+from ..errors import STREAM_TRUNCATED_PREMATURELY, PdfStreamError
+from ._base import ByteStringObject, TextStringObject
+
+
+def hex_to_rgb(value: str) -> tuple[float, float, float]:
+ return tuple(int(value.lstrip("#")[i : i + 2], 16) / 255.0 for i in (0, 2, 4)) # type: ignore
+
+
+def read_hex_string_from_stream(
+ stream: StreamType,
+ forced_encoding: Union[None, str, list[str], dict[int, str]] = None,
+) -> Union["TextStringObject", "ByteStringObject"]:
+ stream.read(1)
+ arr = []
+ x = b""
+ while True:
+ tok = read_non_whitespace(stream)
+ if not tok:
+ raise PdfStreamError(STREAM_TRUNCATED_PREMATURELY)
+ if tok == b">":
+ break
+ x += tok
+ if len(x) == 2:
+ arr.append(int(x, base=16))
+ x = b""
+ if len(x) == 1:
+ x += b"0"
+ if x != b"":
+ arr.append(int(x, base=16))
+ return create_string_object(bytes(arr), forced_encoding)
+
+
+__ESCAPE_DICT__ = {
+ b"n": ord(b"\n"),
+ b"r": ord(b"\r"),
+ b"t": ord(b"\t"),
+ b"b": ord(b"\b"),
+ b"f": ord(b"\f"),
+ b"(": ord(b"("),
+ b")": ord(b")"),
+ b"/": ord(b"/"),
+ b"\\": ord(b"\\"),
+ b" ": ord(b" "),
+ b"%": ord(b"%"),
+ b"<": ord(b"<"),
+ b">": ord(b">"),
+ b"[": ord(b"["),
+ b"]": ord(b"]"),
+ b"#": ord(b"#"),
+ b"_": ord(b"_"),
+ b"&": ord(b"&"),
+ b"$": ord(b"$"),
+}
+__BACKSLASH_CODE__ = 92
+
+
+def read_string_from_stream(
+ stream: StreamType,
+ forced_encoding: Union[None, str, list[str], dict[int, str]] = None,
+) -> Union["TextStringObject", "ByteStringObject"]:
+ tok = stream.read(1)
+ parens = 1
+ txt = []
+ while True:
+ tok = stream.read(1)
+ if not tok:
+ raise PdfStreamError(STREAM_TRUNCATED_PREMATURELY)
+ if tok == b"(":
+ parens += 1
+ elif tok == b")":
+ parens -= 1
+ if parens == 0:
+ break
+ elif tok == b"\\":
+ tok = stream.read(1)
+ try:
+ txt.append(__ESCAPE_DICT__[tok])
+ continue
+ except KeyError:
+ if b"0" <= tok <= b"7":
+ # "The number ddd may consist of one, two, or three
+ # octal digits; high-order overflow shall be ignored.
+ # Three octal digits shall be used, with leading zeros
+ # as needed, if the next character of the string is also
+ # a digit." (PDF reference 7.3.4.2, p 16)
+ sav = stream.tell() - 1
+ for _ in range(2):
+ ntok = stream.read(1)
+ if b"0" <= ntok <= b"7":
+ tok += ntok
+ else:
+ stream.seek(-1, 1) # ntok has to be analyzed
+ break
+ i = int(tok, base=8)
+ if i > 255:
+ txt.append(__BACKSLASH_CODE__)
+ stream.seek(sav)
+ else:
+ txt.append(i)
+ continue
+ if tok in b"\n\r":
+ # This case is hit when a backslash followed by a line
+ # break occurs. If it's a multi-char EOL, consume the
+ # second character:
+ tok = stream.read(1)
+ if tok not in b"\n\r":
+ stream.seek(-1, 1)
+ # Then don't add anything to the actual string, since this
+ # line break was escaped:
+ continue
+ msg = f"Unexpected escaped string: {tok.decode('utf-8', 'ignore')}"
+ logger_warning(msg, __name__)
+ txt.append(__BACKSLASH_CODE__)
+ txt.append(ord(tok))
+ return create_string_object(bytes(txt), forced_encoding)
+
+
+def create_string_object(
+ string: Union[str, bytes],
+ forced_encoding: Union[None, str, list[str], dict[int, str]] = None,
+) -> Union[TextStringObject, ByteStringObject]:
+ """
+ Create a ByteStringObject or a TextStringObject from a string to represent the string.
+
+ Args:
+ string: The data being used
+ forced_encoding: Typically None, or an encoding string
+
+ Returns:
+ A ByteStringObject
+
+ Raises:
+ TypeError: If string is not of type str or bytes.
+
+ """
+ if isinstance(string, str):
+ return TextStringObject(string)
+ if isinstance(string, bytes):
+ if isinstance(forced_encoding, (list, dict)):
+ out = ""
+ for x in string:
+ try:
+ out += forced_encoding[x]
+ except Exception:
+ out += bytes((x,)).decode("charmap")
+ obj = TextStringObject(out)
+ obj._original_bytes = string
+ return obj
+ if isinstance(forced_encoding, str):
+ if forced_encoding == "bytes":
+ return ByteStringObject(string)
+ obj = TextStringObject(string.decode(forced_encoding))
+ obj._original_bytes = string
+ return obj
+ try:
+ if string.startswith((codecs.BOM_UTF16_BE, codecs.BOM_UTF16_LE)):
+ retval = TextStringObject(string.decode("utf-16"))
+ retval._original_bytes = string
+ retval.autodetect_utf16 = True
+ retval.utf16_bom = string[:2]
+ return retval
+ if string.startswith(b"\x00"):
+ retval = TextStringObject(string.decode("utf-16be"))
+ retval._original_bytes = string
+ retval.autodetect_utf16 = True
+ retval.utf16_bom = codecs.BOM_UTF16_BE
+ return retval
+ if string[1:2] == b"\x00":
+ retval = TextStringObject(string.decode("utf-16le"))
+ retval._original_bytes = string
+ retval.autodetect_utf16 = True
+ retval.utf16_bom = codecs.BOM_UTF16_LE
+ return retval
+
+ # This is probably a big performance hit here, but we need
+ # to convert string objects into the text/unicode-aware
+ # version if possible... and the only way to check if that's
+ # possible is to try.
+ # Some strings are strings, some are just byte arrays.
+ retval = TextStringObject(decode_pdfdocencoding(string))
+ retval._original_bytes = string
+ retval.autodetect_pdfdocencoding = True
+ return retval
+ except UnicodeDecodeError:
+ return ByteStringObject(string)
+ else:
+ raise TypeError("create_string_object should have str or unicode arg")
+
+
+def decode_pdfdocencoding(byte_array: bytes) -> str:
+ retval = ""
+ for b in byte_array:
+ c = _pdfdoc_encoding[b]
+ if c == "\u0000":
+ raise UnicodeDecodeError(
+ "pdfdocencoding",
+ bytearray(b),
+ -1,
+ -1,
+ "does not exist in translation table",
+ )
+ retval += c
+ return retval
diff --git a/venv/lib/python3.12/site-packages/pypdf/generic/_viewerpref.py b/venv/lib/python3.12/site-packages/pypdf/generic/_viewerpref.py
new file mode 100644
index 0000000..7a767d8
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/generic/_viewerpref.py
@@ -0,0 +1,163 @@
+# Copyright (c) 2023, Pubpub-ZZ
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+# * 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.
+# * The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
+
+from typing import (
+ Any,
+ Optional,
+)
+
+from ._base import BooleanObject, NameObject, NumberObject, is_null_or_none
+from ._data_structures import ArrayObject, DictionaryObject
+
+f_obj = BooleanObject(False)
+
+
+class ViewerPreferences(DictionaryObject):
+ def __init__(self, obj: Optional[DictionaryObject] = None) -> None:
+ super().__init__(self)
+ if not is_null_or_none(obj):
+ self.update(obj.items()) # type: ignore
+ try:
+ self.indirect_reference = obj.indirect_reference # type: ignore
+ except AttributeError:
+ pass
+
+ def _get_bool(self, key: str, default: Optional[BooleanObject]) -> Optional[BooleanObject]:
+ return self.get(key, default)
+
+ def _set_bool(self, key: str, v: bool) -> None:
+ self[NameObject(key)] = BooleanObject(v is True)
+
+ def _get_name(self, key: str, default: Optional[NameObject]) -> Optional[NameObject]:
+ return self.get(key, default)
+
+ def _set_name(self, key: str, lst: list[str], v: NameObject) -> None:
+ if v[0] != "/":
+ raise ValueError(f"{v} does not start with '/'")
+ if lst != [] and v not in lst:
+ raise ValueError(f"{v} is an unacceptable value")
+ self[NameObject(key)] = NameObject(v)
+
+ def _get_arr(self, key: str, default: Optional[list[Any]]) -> Optional[ArrayObject]:
+ return self.get(key, None if default is None else ArrayObject(default))
+
+ def _set_arr(self, key: str, v: Optional[ArrayObject]) -> None:
+ if v is None:
+ try:
+ del self[NameObject(key)]
+ except KeyError:
+ pass
+ return
+ if not isinstance(v, ArrayObject):
+ raise ValueError("ArrayObject is expected")
+ self[NameObject(key)] = v
+
+ def _get_int(self, key: str, default: Optional[NumberObject]) -> Optional[NumberObject]:
+ return self.get(key, default)
+
+ def _set_int(self, key: str, v: int) -> None:
+ self[NameObject(key)] = NumberObject(v)
+
+ @property
+ def PRINT_SCALING(self) -> NameObject:
+ return NameObject("/PrintScaling")
+
+ def __new__(cls: Any, value: Any = None) -> "ViewerPreferences":
+ def _add_prop_bool(key: str, default: Optional[BooleanObject]) -> property:
+ return property(
+ lambda self: self._get_bool(key, default),
+ lambda self, v: self._set_bool(key, v),
+ None,
+ f"""
+ Returns/Modify the status of {key}, Returns {default} if not defined
+ """,
+ )
+
+ def _add_prop_name(
+ key: str, lst: list[str], default: Optional[NameObject]
+ ) -> property:
+ return property(
+ lambda self: self._get_name(key, default),
+ lambda self, v: self._set_name(key, lst, v),
+ None,
+ f"""
+ Returns/Modify the status of {key}, Returns {default} if not defined.
+ Acceptable values: {lst}
+ """,
+ )
+
+ def _add_prop_arr(key: str, default: Optional[ArrayObject]) -> property:
+ return property(
+ lambda self: self._get_arr(key, default),
+ lambda self, v: self._set_arr(key, v),
+ None,
+ f"""
+ Returns/Modify the status of {key}, Returns {default} if not defined
+ """,
+ )
+
+ def _add_prop_int(key: str, default: Optional[int]) -> property:
+ return property(
+ lambda self: self._get_int(key, default),
+ lambda self, v: self._set_int(key, v),
+ None,
+ f"""
+ Returns/Modify the status of {key}, Returns {default} if not defined
+ """,
+ )
+
+ cls.hide_toolbar = _add_prop_bool("/HideToolbar", f_obj)
+ cls.hide_menubar = _add_prop_bool("/HideMenubar", f_obj)
+ cls.hide_windowui = _add_prop_bool("/HideWindowUI", f_obj)
+ cls.fit_window = _add_prop_bool("/FitWindow", f_obj)
+ cls.center_window = _add_prop_bool("/CenterWindow", f_obj)
+ cls.display_doctitle = _add_prop_bool("/DisplayDocTitle", f_obj)
+
+ cls.non_fullscreen_pagemode = _add_prop_name(
+ "/NonFullScreenPageMode",
+ ["/UseNone", "/UseOutlines", "/UseThumbs", "/UseOC"],
+ NameObject("/UseNone"),
+ )
+ cls.direction = _add_prop_name(
+ "/Direction", ["/L2R", "/R2L"], NameObject("/L2R")
+ )
+ cls.view_area = _add_prop_name("/ViewArea", [], None)
+ cls.view_clip = _add_prop_name("/ViewClip", [], None)
+ cls.print_area = _add_prop_name("/PrintArea", [], None)
+ cls.print_clip = _add_prop_name("/PrintClip", [], None)
+ cls.print_scaling = _add_prop_name("/PrintScaling", [], None)
+ cls.duplex = _add_prop_name(
+ "/Duplex", ["/Simplex", "/DuplexFlipShortEdge", "/DuplexFlipLongEdge"], None
+ )
+ cls.pick_tray_by_pdfsize = _add_prop_bool("/PickTrayByPDFSize", None)
+ cls.print_pagerange = _add_prop_arr("/PrintPageRange", None)
+ cls.num_copies = _add_prop_int("/NumCopies", None)
+
+ cls.enforce = _add_prop_arr("/Enforce", ArrayObject())
+
+ return DictionaryObject.__new__(cls)
diff --git a/venv/lib/python3.12/site-packages/pypdf/pagerange.py b/venv/lib/python3.12/site-packages/pypdf/pagerange.py
new file mode 100644
index 0000000..2ff4613
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/pagerange.py
@@ -0,0 +1,200 @@
+"""
+Representation and utils for ranges of PDF file pages.
+
+Copyright (c) 2014, Steve Witham .
+All rights reserved. This software is available under a BSD license;
+see https://github.com/py-pdf/pypdf/blob/main/LICENSE
+"""
+
+import re
+from typing import Any, Union
+
+from .errors import ParseError
+
+_INT_RE = r"(0|-?[1-9]\d*)" # A decimal int, don't allow "-0".
+PAGE_RANGE_RE = f"^({_INT_RE}|({_INT_RE}?(:{_INT_RE}?(:{_INT_RE}?)?)))$"
+# groups: 12 34 5 6 7 8
+
+
+class PageRange:
+ """
+ A slice-like representation of a range of page indices.
+
+ For example, page numbers, only starting at zero.
+
+ The syntax is like what you would put between brackets [ ].
+ The slice is one of the few Python types that can't be subclassed,
+ but this class converts to and from slices, and allows similar use.
+
+ - PageRange(str) parses a string representing a page range.
+ - PageRange(slice) directly "imports" a slice.
+ - to_slice() gives the equivalent slice.
+ - str() and repr() allow printing.
+ - indices(n) is like slice.indices(n).
+ """
+
+ def __init__(self, arg: Union[slice, "PageRange", str]) -> None:
+ """
+ Initialize with either a slice -- giving the equivalent page range,
+ or a PageRange object -- making a copy,
+ or a string like
+ "int", "[int]:[int]" or "[int]:[int]:[int]",
+ where the brackets indicate optional ints.
+ Remember, page indices start with zero.
+ Page range expression examples:
+
+ : all pages. -1 last page.
+ 22 just the 23rd page. :-1 all but the last page.
+ 0:3 the first three pages. -2 second-to-last page.
+ :3 the first three pages. -2: last two pages.
+ 5: from the sixth page onward. -3:-1 third & second to last.
+ The third, "stride" or "step" number is also recognized.
+ ::2 0 2 4 ... to the end. 3:0:-1 3 2 1 but not 0.
+ 1:10:2 1 3 5 7 9 2::-1 2 1 0.
+ ::-1 all pages in reverse order.
+ Note the difference between this notation and arguments to slice():
+ slice(3) means the first three pages;
+ PageRange("3") means the range of only the fourth page.
+ However PageRange(slice(3)) means the first three pages.
+ """
+ if isinstance(arg, slice):
+ self._slice = arg
+ return
+
+ if isinstance(arg, PageRange):
+ self._slice = arg.to_slice()
+ return
+
+ m = isinstance(arg, str) and re.match(PAGE_RANGE_RE, arg)
+ if not m:
+ raise ParseError(arg)
+ if m.group(2):
+ # Special case: just an int means a range of one page.
+ start = int(m.group(2))
+ stop = start + 1 if start != -1 else None
+ self._slice = slice(start, stop)
+ else:
+ self._slice = slice(*[int(g) if g else None for g in m.group(4, 6, 8)])
+
+ @staticmethod
+ def valid(input: Any) -> bool:
+ """
+ True if input is a valid initializer for a PageRange.
+
+ Args:
+ input: A possible PageRange string or a PageRange object.
+
+ Returns:
+ True, if the ``input`` is a valid PageRange.
+
+ """
+ return isinstance(input, (slice, PageRange)) or (
+ isinstance(input, str) and bool(re.match(PAGE_RANGE_RE, input))
+ )
+
+ def to_slice(self) -> slice:
+ """Return the slice equivalent of this page range."""
+ return self._slice
+
+ def __str__(self) -> str:
+ """A string like "1:2:3"."""
+ s = self._slice
+ indices: Union[tuple[int, int], tuple[int, int, int]]
+ if s.step is None:
+ if s.start is not None and s.stop == s.start + 1:
+ return str(s.start)
+
+ indices = s.start, s.stop
+ else:
+ indices = s.start, s.stop, s.step
+ return ":".join("" if i is None else str(i) for i in indices)
+
+ def __repr__(self) -> str:
+ """A string like "PageRange('1:2:3')"."""
+ return "PageRange(" + repr(str(self)) + ")"
+
+ def indices(self, n: int) -> tuple[int, int, int]:
+ """
+ Assuming a sequence of length n, calculate the start and stop indices,
+ and the stride length of the PageRange.
+
+ See help(slice.indices).
+
+ Args:
+ n: the length of the list of pages to choose from.
+
+ Returns:
+ Arguments for range().
+
+ """
+ return self._slice.indices(n)
+
+ def __eq__(self, other: object) -> bool:
+ if not isinstance(other, PageRange):
+ return False
+ return self._slice == other._slice
+
+ def __hash__(self) -> int:
+ return hash((self.__class__, (self._slice.start, self._slice.stop, self._slice.step)))
+
+ def __add__(self, other: "PageRange") -> "PageRange":
+ if not isinstance(other, PageRange):
+ raise TypeError(f"Can't add PageRange and {type(other)}")
+ if self._slice.step is not None or other._slice.step is not None:
+ raise ValueError("Can't add PageRange with stride")
+ a = self._slice.start, self._slice.stop
+ b = other._slice.start, other._slice.stop
+
+ if a[0] > b[0]:
+ a, b = b, a
+
+ # Now a[0] is the smallest
+ if b[0] > a[1]:
+ # There is a gap between a and b.
+ raise ValueError("Can't add PageRanges with gap")
+ return PageRange(slice(a[0], max(a[1], b[1])))
+
+
+PAGE_RANGE_ALL = PageRange(":") # The range of all pages.
+
+
+def parse_filename_page_ranges(
+ args: list[Union[str, PageRange, None]]
+) -> list[tuple[str, PageRange]]:
+ """
+ Given a list of filenames and page ranges, return a list of (filename, page_range) pairs.
+
+ Args:
+ args: A list where the first element is a filename. The other elements are
+ filenames, page-range expressions, slice objects, or PageRange objects.
+ A filename not followed by a page range indicates all pages of the file.
+
+ Returns:
+ A list of (filename, page_range) pairs.
+
+ """
+ pairs: list[tuple[str, PageRange]] = []
+ pdf_filename: Union[str, None] = None
+ did_page_range = False
+ for arg in [*args, None]:
+ if PageRange.valid(arg):
+ if not pdf_filename:
+ raise ValueError(
+ "The first argument must be a filename, not a page range."
+ )
+
+ assert arg is not None
+ pairs.append((pdf_filename, PageRange(arg)))
+ did_page_range = True
+ else:
+ # New filename or end of list - use the complete previous file?
+ if pdf_filename and not did_page_range:
+ pairs.append((pdf_filename, PAGE_RANGE_ALL))
+
+ assert not isinstance(arg, PageRange), arg
+ pdf_filename = arg
+ did_page_range = False
+ return pairs
+
+
+PageRangeSpec = Union[str, PageRange, tuple[int, int], tuple[int, int, int], list[int]]
diff --git a/venv/lib/python3.12/site-packages/pypdf/papersizes.py b/venv/lib/python3.12/site-packages/pypdf/papersizes.py
new file mode 100644
index 0000000..ed09f34
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/papersizes.py
@@ -0,0 +1,52 @@
+"""Helper to get paper sizes."""
+
+from typing import NamedTuple
+
+
+class Dimensions(NamedTuple):
+ width: int
+ height: int
+
+
+class PaperSize:
+ """(width, height) of the paper in portrait mode in pixels at 72 ppi."""
+
+ # Notes of how to calculate it:
+ # 1. Get the size of the paper in millimeters
+ # 2. Convert it to inches (25.4 millimeters is equal to 1 inch)
+ # 3. Convert it to pixels at 72dpi (1 inch is equal to 72 pixels)
+
+ # All Din-A paper sizes follow this pattern:
+ # 2 x A(n - 1) = A(n)
+ # So the height of the next bigger one is the width of the smaller one
+ # The ratio is always approximately 1:2**0.5
+ # Additionally, A0 is defined to have an area of 1 m**2
+ # https://en.wikipedia.org/wiki/ISO_216
+ # Be aware of rounding issues!
+ A0 = Dimensions(2384, 3370) # 841mm x 1189mm
+ A1 = Dimensions(1684, 2384)
+ A2 = Dimensions(1191, 1684)
+ A3 = Dimensions(842, 1191)
+ A4 = Dimensions(
+ 595, 842
+ ) # Printer paper, documents - this is by far the most common
+ A5 = Dimensions(420, 595) # Paperback books
+ A6 = Dimensions(298, 420) # Postcards
+ A7 = Dimensions(210, 298)
+ A8 = Dimensions(147, 210)
+
+ # Envelopes
+ C4 = Dimensions(649, 918)
+
+
+_din_a = (
+ PaperSize.A0,
+ PaperSize.A1,
+ PaperSize.A2,
+ PaperSize.A3,
+ PaperSize.A4,
+ PaperSize.A5,
+ PaperSize.A6,
+ PaperSize.A7,
+ PaperSize.A8,
+)
diff --git a/venv/lib/python3.12/site-packages/pypdf/py.typed b/venv/lib/python3.12/site-packages/pypdf/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/venv/lib/python3.12/site-packages/pypdf/types.py b/venv/lib/python3.12/site-packages/pypdf/types.py
new file mode 100644
index 0000000..a1c4e49
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/types.py
@@ -0,0 +1,80 @@
+"""Helpers for working with PDF types."""
+
+import sys
+from typing import Literal, Union
+
+if sys.version_info[:2] >= (3, 10):
+ # Python 3.10+: https://www.python.org/dev/peps/pep-0484
+ from typing import TypeAlias
+else:
+ from typing_extensions import TypeAlias
+
+from .generic._base import NameObject, NullObject, NumberObject
+from .generic._data_structures import ArrayObject, Destination
+from .generic._outline import OutlineItem
+
+BorderArrayType: TypeAlias = list[Union[NameObject, NumberObject, ArrayObject]]
+
+OutlineItemType: TypeAlias = Union[OutlineItem, Destination]
+
+FitType: TypeAlias = Literal[
+ "/XYZ", "/Fit", "/FitH", "/FitV", "/FitR", "/FitB", "/FitBH", "/FitBV"
+]
+# These go with the FitType, they specify values for the fit
+ZoomArgType: TypeAlias = Union[NumberObject, NullObject, float]
+ZoomArgsType: TypeAlias = list[ZoomArgType]
+
+# Recursive types like the following are not yet supported by Sphinx:
+# OutlineType = List[Union[Destination, "OutlineType"]]
+# Hence use this for the moment:
+OutlineType = list[Union[Destination, list[Union[Destination, list[Destination]]]]]
+
+LayoutType: TypeAlias = Literal[
+ "/NoLayout",
+ "/SinglePage",
+ "/OneColumn",
+ "/TwoColumnLeft",
+ "/TwoColumnRight",
+ "/TwoPageLeft",
+ "/TwoPageRight",
+]
+
+PagemodeType: TypeAlias = Literal[
+ "/UseNone",
+ "/UseOutlines",
+ "/UseThumbs",
+ "/FullScreen",
+ "/UseOC",
+ "/UseAttachments",
+]
+
+AnnotationSubtype: TypeAlias = Literal[
+ "/Text",
+ "/Link",
+ "/FreeText",
+ "/Line",
+ "/Square",
+ "/Circle",
+ "/Polygon",
+ "/PolyLine",
+ "/Highlight",
+ "/Underline",
+ "/Squiggly",
+ "/StrikeOut",
+ "/Caret",
+ "/Stamp",
+ "/Ink",
+ "/Popup",
+ "/FileAttachment",
+ "/Sound",
+ "/Movie",
+ "/Screen",
+ "/Widget",
+ "/PrinterMark",
+ "/TrapNet",
+ "/Watermark",
+ "/3D",
+ "/Redact",
+ "/Projection",
+ "/RichMedia",
+]
diff --git a/venv/lib/python3.12/site-packages/pypdf/xmp.py b/venv/lib/python3.12/site-packages/pypdf/xmp.py
new file mode 100644
index 0000000..8de1965
--- /dev/null
+++ b/venv/lib/python3.12/site-packages/pypdf/xmp.py
@@ -0,0 +1,748 @@
+"""
+Anything related to Extensible Metadata Platform (XMP) metadata.
+
+https://en.wikipedia.org/wiki/Extensible_Metadata_Platform
+"""
+
+import datetime
+import decimal
+import re
+from collections.abc import Iterator
+from typing import (
+ Any,
+ Callable,
+ Optional,
+ TypeVar,
+ Union,
+)
+from xml.dom.minidom import Document, parseString
+from xml.dom.minidom import Element as XmlElement
+from xml.parsers.expat import ExpatError
+
+from ._protocols import XmpInformationProtocol
+from ._utils import StreamType, deprecate_with_replacement, deprecation_no_replacement
+from .errors import PdfReadError, XmpDocumentError
+from .generic import ContentStream, PdfObject
+
+RDF_NAMESPACE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+DC_NAMESPACE = "http://purl.org/dc/elements/1.1/"
+XMP_NAMESPACE = "http://ns.adobe.com/xap/1.0/"
+PDF_NAMESPACE = "http://ns.adobe.com/pdf/1.3/"
+XMPMM_NAMESPACE = "http://ns.adobe.com/xap/1.0/mm/"
+
+# What is the PDFX namespace, you might ask?
+# It's documented here: https://github.com/adobe/xmp-docs/raw/master/XMPSpecifications/XMPSpecificationPart3.pdf
+# This namespace is used to place "custom metadata"
+# properties, which are arbitrary metadata properties with no semantic or
+# documented meaning.
+#
+# Elements in the namespace are key/value-style storage,
+# where the element name is the key and the content is the value. The keys
+# are transformed into valid XML identifiers by substituting an invalid
+# identifier character with \u2182 followed by the unicode hex ID of the
+# original character. A key like "my car" is therefore "my\u21820020car".
+#
+# \u2182 is the unicode character \u{ROMAN NUMERAL TEN THOUSAND}
+#
+# The pdfx namespace should be avoided.
+# A custom data schema and sensical XML elements could be used instead, as is
+# suggested by Adobe's own documentation on XMP under "Extensibility of
+# Schemas".
+PDFX_NAMESPACE = "http://ns.adobe.com/pdfx/1.3/"
+
+# PDF/A
+PDFAID_NAMESPACE = "http://www.aiim.org/pdfa/ns/id/"
+
+# Internal mapping of namespace URI → prefix
+_NAMESPACE_PREFIX_MAP = {
+ DC_NAMESPACE: "dc",
+ XMP_NAMESPACE: "xmp",
+ PDF_NAMESPACE: "pdf",
+ XMPMM_NAMESPACE: "xmpMM",
+ PDFAID_NAMESPACE: "pdfaid",
+ PDFX_NAMESPACE: "pdfx",
+}
+
+iso8601 = re.compile(
+ """
+ (?P[0-9]{4})
+ (-
+ (?P[0-9]{2})
+ (-
+ (?P[0-9]+)
+ (T
+ (?P[0-9]{2}):
+ (?P[0-9]{2})
+ (:(?P[0-9]{2}(.[0-9]+)?))?
+ (?PZ|[-+][0-9]{2}:[0-9]{2})
+ )?
+ )?
+ )?
+ """,
+ re.VERBOSE,
+)
+
+
+K = TypeVar("K")
+
+# Minimal XMP template
+_MINIMAL_XMP = f"""
+
+
+
+
+
+
+"""
+
+
+def _identity(value: K) -> K:
+ return value
+
+
+def _converter_date(value: str) -> datetime.datetime:
+ matches = iso8601.match(value)
+ if matches is None:
+ raise ValueError(f"Invalid date format: {value}")
+ year = int(matches.group("year"))
+ month = int(matches.group("month") or "1")
+ day = int(matches.group("day") or "1")
+ hour = int(matches.group("hour") or "0")
+ minute = int(matches.group("minute") or "0")
+ second = decimal.Decimal(matches.group("second") or "0")
+ seconds_dec = second.to_integral(decimal.ROUND_FLOOR)
+ milliseconds_dec = (second - seconds_dec) * 1_000_000
+
+ seconds = int(seconds_dec)
+ milliseconds = int(milliseconds_dec)
+
+ tzd = matches.group("tzd") or "Z"
+ dt = datetime.datetime(year, month, day, hour, minute, seconds, milliseconds)
+ if tzd != "Z":
+ tzd_hours, tzd_minutes = (int(x) for x in tzd.split(":"))
+ tzd_hours *= -1
+ if tzd_hours < 0:
+ tzd_minutes *= -1
+ dt = dt + datetime.timedelta(hours=tzd_hours, minutes=tzd_minutes)
+ return dt
+
+
+def _format_datetime_utc(value: datetime.datetime) -> str:
+ """Format a datetime as UTC with trailing 'Z'.
+
+ - If the input is timezone-aware, convert to UTC first.
+ - If naive, assume UTC.
+ """
+ if value.tzinfo is not None and value.utcoffset() is not None:
+ value = value.astimezone(datetime.timezone.utc)
+
+ value = value.replace(tzinfo=None)
+ return value.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+
+
+def _generic_get(
+ element: XmlElement, self: "XmpInformation", list_type: str, converter: Callable[[Any], Any] = _identity
+) -> Optional[list[str]]:
+ containers = element.getElementsByTagNameNS(RDF_NAMESPACE, list_type)
+ retval: list[Any] = []
+ if len(containers):
+ for container in containers:
+ for item in container.getElementsByTagNameNS(RDF_NAMESPACE, "li"):
+ value = self._get_text(item)
+ value = converter(value)
+ retval.append(value)
+ return retval
+ return None
+
+
+class XmpInformation(XmpInformationProtocol, PdfObject):
+ """
+ An object that represents Extensible Metadata Platform (XMP) metadata.
+ Usually accessed by :py:attr:`xmp_metadata()`.
+
+ Raises:
+ PdfReadError: if XML is invalid
+
+ """
+
+ def __init__(self, stream: ContentStream) -> None:
+ self.stream = stream
+ try:
+ data = self.stream.get_data()
+ doc_root: Document = parseString(data) # noqa: S318
+ except (AttributeError, ExpatError) as e:
+ raise PdfReadError(f"XML in XmpInformation was invalid: {e}")
+ self.rdf_root: XmlElement = doc_root.getElementsByTagNameNS(
+ RDF_NAMESPACE, "RDF"
+ )[0]
+ self.cache: dict[Any, Any] = {}
+
+ @classmethod
+ def create(cls) -> "XmpInformation":
+ """
+ Create a new XmpInformation object with minimal structure.
+
+ Returns:
+ A new XmpInformation instance with empty metadata fields.
+ """
+ stream = ContentStream(None, None)
+ stream.set_data(_MINIMAL_XMP.encode("utf-8"))
+ return cls(stream)
+
+ def write_to_stream(
+ self, stream: StreamType, encryption_key: Union[None, str, bytes] = None
+ ) -> None:
+ deprecate_with_replacement(
+ "XmpInformation.write_to_stream",
+ "PdfWriter.xmp_metadata",
+ "6.0.0"
+ )
+ if encryption_key is not None: # deprecated
+ deprecation_no_replacement(
+ "the encryption_key parameter of write_to_stream", "5.0.0"
+ )
+ self.stream.write_to_stream(stream)
+
+ def get_element(self, about_uri: str, namespace: str, name: str) -> Iterator[Any]:
+ for desc in self.rdf_root.getElementsByTagNameNS(RDF_NAMESPACE, "Description"):
+ if desc.getAttributeNS(RDF_NAMESPACE, "about") == about_uri:
+ attr = desc.getAttributeNodeNS(namespace, name)
+ if attr is not None:
+ yield attr
+ yield from desc.getElementsByTagNameNS(namespace, name)
+
+ def get_nodes_in_namespace(self, about_uri: str, namespace: str) -> Iterator[Any]:
+ for desc in self.rdf_root.getElementsByTagNameNS(RDF_NAMESPACE, "Description"):
+ if desc.getAttributeNS(RDF_NAMESPACE, "about") == about_uri:
+ for i in range(desc.attributes.length):
+ attr = desc.attributes.item(i)
+ if attr and attr.namespaceURI == namespace:
+ yield attr
+ for child in desc.childNodes:
+ if child.namespaceURI == namespace:
+ yield child
+
+ def _get_text(self, element: XmlElement) -> str:
+ text = ""
+ for child in element.childNodes:
+ if child.nodeType == child.TEXT_NODE:
+ text += child.data
+ return text
+
+ def _get_single_value(
+ self,
+ namespace: str,
+ name: str,
+ converter: Callable[[str], Any] = _identity,
+ ) -> Optional[Any]:
+ cached = self.cache.get(namespace, {}).get(name)
+ if cached:
+ return cached
+ value = None
+ for element in self.get_element("", namespace, name):
+ if element.nodeType == element.ATTRIBUTE_NODE:
+ value = element.nodeValue
+ else:
+ value = self._get_text(element)
+ break
+ if value is not None:
+ value = converter(value)
+ ns_cache = self.cache.setdefault(namespace, {})
+ ns_cache[name] = value
+ return value
+
+ def _getter_bag(self, namespace: str, name: str) -> Optional[list[str]]:
+ cached = self.cache.get(namespace, {}).get(name)
+ if cached:
+ return cached
+ retval: list[str] = []
+ for element in self.get_element("", namespace, name):
+ if (bags := _generic_get(element, self, list_type="Bag")) is not None:
+ retval.extend(bags)
+ else:
+ value = self._get_text(element)
+ retval.append(value)
+ ns_cache = self.cache.setdefault(namespace, {})
+ ns_cache[name] = retval
+ return retval
+
+ def _get_seq_values(
+ self,
+ namespace: str,
+ name: str,
+ converter: Callable[[Any], Any] = _identity,
+ ) -> Optional[list[Any]]:
+ cached = self.cache.get(namespace, {}).get(name)
+ if cached:
+ return cached
+ retval: list[Any] = []
+ for element in self.get_element("", namespace, name):
+ if (seqs := _generic_get(element, self, list_type="Seq", converter=converter)) is not None:
+ retval.extend(seqs)
+ elif (bags := _generic_get(element, self, list_type="Bag")) is not None:
+ # See issue at https://github.com/py-pdf/pypdf/issues/3324
+ # Some applications violate the XMP metadata standard regarding `dc:creator` which should
+ # be an "ordered array" and thus a sequence, but use an unordered array (bag) instead.
+ # This seems to stem from the fact that the original Dublin Core specification does indeed
+ # use bags or direct values, while PDFs are expected to follow the XMP standard and ignore
+ # the plain Dublin Core variant. For this reason, add a fallback here to deal with such
+ # issues accordingly.
+ retval.extend(bags)
+ else:
+ value = converter(self._get_text(element))
+ retval.append(value)
+ ns_cache = self.cache.setdefault(namespace, {})
+ ns_cache[name] = retval
+ return retval
+
+ def _get_langalt_values(self, namespace: str, name: str) -> Optional[dict[Any, Any]]:
+ cached = self.cache.get(namespace, {}).get(name)
+ if cached:
+ return cached
+ retval: dict[Any, Any] = {}
+ for element in self.get_element("", namespace, name):
+ alts = element.getElementsByTagNameNS(RDF_NAMESPACE, "Alt")
+ if len(alts):
+ for alt in alts:
+ for item in alt.getElementsByTagNameNS(RDF_NAMESPACE, "li"):
+ value = self._get_text(item)
+ retval[item.getAttribute("xml:lang")] = value
+ else:
+ retval["x-default"] = self._get_text(element)
+ ns_cache = self.cache.setdefault(namespace, {})
+ ns_cache[name] = retval
+ return retval
+
+ @property
+ def dc_contributor(self) -> Optional[list[str]]:
+ """Contributors to the resource (other than the authors)."""
+ return self._getter_bag(DC_NAMESPACE, "contributor")
+
+ @dc_contributor.setter
+ def dc_contributor(self, values: Optional[list[str]]) -> None:
+ self._set_bag_values(DC_NAMESPACE, "contributor", values)
+
+ @property
+ def dc_coverage(self) -> Optional[str]:
+ """Text describing the extent or scope of the resource."""
+ return self._get_single_value(DC_NAMESPACE, "coverage")
+
+ @dc_coverage.setter
+ def dc_coverage(self, value: Optional[str]) -> None:
+ self._set_single_value(DC_NAMESPACE, "coverage", value)
+
+ @property
+ def dc_creator(self) -> Optional[list[str]]:
+ """A sorted array of names of the authors of the resource, listed in order of precedence."""
+ return self._get_seq_values(DC_NAMESPACE, "creator")
+
+ @dc_creator.setter
+ def dc_creator(self, values: Optional[list[str]]) -> None:
+ self._set_seq_values(DC_NAMESPACE, "creator", values)
+
+ @property
+ def dc_date(self) -> Optional[list[datetime.datetime]]:
+ """A sorted array of dates of significance to the resource. The dates and times are in UTC."""
+ return self._get_seq_values(DC_NAMESPACE, "date", _converter_date)
+
+ @dc_date.setter
+ def dc_date(self, values: Optional[list[Union[str, datetime.datetime]]]) -> None:
+ if values is None:
+ self._set_seq_values(DC_NAMESPACE, "date", None)
+ else:
+ date_strings = []
+ for value in values:
+ if isinstance(value, datetime.datetime):
+ date_strings.append(_format_datetime_utc(value))
+ else:
+ date_strings.append(str(value))
+ self._set_seq_values(DC_NAMESPACE, "date", date_strings)
+
+ @property
+ def dc_description(self) -> Optional[dict[str, str]]:
+ """A language-keyed dictionary of textual descriptions of the content of the resource."""
+ return self._get_langalt_values(DC_NAMESPACE, "description")
+
+ @dc_description.setter
+ def dc_description(self, values: Optional[dict[str, str]]) -> None:
+ self._set_langalt_values(DC_NAMESPACE, "description", values)
+
+ @property
+ def dc_format(self) -> Optional[str]:
+ """The mime-type of the resource."""
+ return self._get_single_value(DC_NAMESPACE, "format")
+
+ @dc_format.setter
+ def dc_format(self, value: Optional[str]) -> None:
+ self._set_single_value(DC_NAMESPACE, "format", value)
+
+ @property
+ def dc_identifier(self) -> Optional[str]:
+ """Unique identifier of the resource."""
+ return self._get_single_value(DC_NAMESPACE, "identifier")
+
+ @dc_identifier.setter
+ def dc_identifier(self, value: Optional[str]) -> None:
+ self._set_single_value(DC_NAMESPACE, "identifier", value)
+
+ @property
+ def dc_language(self) -> Optional[list[str]]:
+ """An unordered array specifying the languages used in the resource."""
+ return self._getter_bag(DC_NAMESPACE, "language")
+
+ @dc_language.setter
+ def dc_language(self, values: Optional[list[str]]) -> None:
+ self._set_bag_values(DC_NAMESPACE, "language", values)
+
+ @property
+ def dc_publisher(self) -> Optional[list[str]]:
+ """An unordered array of publisher names."""
+ return self._getter_bag(DC_NAMESPACE, "publisher")
+
+ @dc_publisher.setter
+ def dc_publisher(self, values: Optional[list[str]]) -> None:
+ self._set_bag_values(DC_NAMESPACE, "publisher", values)
+
+ @property
+ def dc_relation(self) -> Optional[list[str]]:
+ """An unordered array of text descriptions of relationships to other documents."""
+ return self._getter_bag(DC_NAMESPACE, "relation")
+
+ @dc_relation.setter
+ def dc_relation(self, values: Optional[list[str]]) -> None:
+ self._set_bag_values(DC_NAMESPACE, "relation", values)
+
+ @property
+ def dc_rights(self) -> Optional[dict[str, str]]:
+ """A language-keyed dictionary of textual descriptions of the rights the user has to this resource."""
+ return self._get_langalt_values(DC_NAMESPACE, "rights")
+
+ @dc_rights.setter
+ def dc_rights(self, values: Optional[dict[str, str]]) -> None:
+ self._set_langalt_values(DC_NAMESPACE, "rights", values)
+
+ @property
+ def dc_source(self) -> Optional[str]:
+ """Unique identifier of the work from which this resource was derived."""
+ return self._get_single_value(DC_NAMESPACE, "source")
+
+ @dc_source.setter
+ def dc_source(self, value: Optional[str]) -> None:
+ self._set_single_value(DC_NAMESPACE, "source", value)
+
+ @property
+ def dc_subject(self) -> Optional[list[str]]:
+ """An unordered array of descriptive phrases or keywords that specify the topic of the content."""
+ return self._getter_bag(DC_NAMESPACE, "subject")
+
+ @dc_subject.setter
+ def dc_subject(self, values: Optional[list[str]]) -> None:
+ self._set_bag_values(DC_NAMESPACE, "subject", values)
+
+ @property
+ def dc_title(self) -> Optional[dict[str, str]]:
+ """A language-keyed dictionary of the title of the resource."""
+ return self._get_langalt_values(DC_NAMESPACE, "title")
+
+ @dc_title.setter
+ def dc_title(self, values: Optional[dict[str, str]]) -> None:
+ self._set_langalt_values(DC_NAMESPACE, "title", values)
+
+ @property
+ def dc_type(self) -> Optional[list[str]]:
+ """An unordered array of textual descriptions of the document type."""
+ return self._getter_bag(DC_NAMESPACE, "type")
+
+ @dc_type.setter
+ def dc_type(self, values: Optional[list[str]]) -> None:
+ self._set_bag_values(DC_NAMESPACE, "type", values)
+
+ @property
+ def pdf_keywords(self) -> Optional[str]:
+ """An unformatted text string representing document keywords."""
+ return self._get_single_value(PDF_NAMESPACE, "Keywords")
+
+ @pdf_keywords.setter
+ def pdf_keywords(self, value: Optional[str]) -> None:
+ self._set_single_value(PDF_NAMESPACE, "Keywords", value)
+
+ @property
+ def pdf_pdfversion(self) -> Optional[str]:
+ """The PDF file version, for example 1.0 or 1.3."""
+ return self._get_single_value(PDF_NAMESPACE, "PDFVersion")
+
+ @pdf_pdfversion.setter
+ def pdf_pdfversion(self, value: Optional[str]) -> None:
+ self._set_single_value(PDF_NAMESPACE, "PDFVersion", value)
+
+ @property
+ def pdf_producer(self) -> Optional[str]:
+ """The name of the tool that saved the document as a PDF."""
+ return self._get_single_value(PDF_NAMESPACE, "Producer")
+
+ @pdf_producer.setter
+ def pdf_producer(self, value: Optional[str]) -> None:
+ self._set_single_value(PDF_NAMESPACE, "Producer", value)
+
+ @property
+ def xmp_create_date(self) -> Optional[datetime.datetime]:
+ """The date and time the resource was originally created. Returned as a UTC datetime object."""
+ return self._get_single_value(XMP_NAMESPACE, "CreateDate", _converter_date)
+
+ @xmp_create_date.setter
+ def xmp_create_date(self, value: Optional[datetime.datetime]) -> None:
+ if value:
+ date_str = _format_datetime_utc(value)
+ self._set_single_value(XMP_NAMESPACE, "CreateDate", date_str)
+ else:
+ self._set_single_value(XMP_NAMESPACE, "CreateDate", None)
+
+ @property
+ def xmp_modify_date(self) -> Optional[datetime.datetime]:
+ """The date and time the resource was last modified. Returned as a UTC datetime object."""
+ return self._get_single_value(XMP_NAMESPACE, "ModifyDate", _converter_date)
+
+ @xmp_modify_date.setter
+ def xmp_modify_date(self, value: Optional[datetime.datetime]) -> None:
+ if value:
+ date_str = _format_datetime_utc(value)
+ self._set_single_value(XMP_NAMESPACE, "ModifyDate", date_str)
+ else:
+ self._set_single_value(XMP_NAMESPACE, "ModifyDate", None)
+
+ @property
+ def xmp_metadata_date(self) -> Optional[datetime.datetime]:
+ """The date and time that any metadata for this resource was last changed. Returned as a UTC datetime object."""
+ return self._get_single_value(XMP_NAMESPACE, "MetadataDate", _converter_date)
+
+ @xmp_metadata_date.setter
+ def xmp_metadata_date(self, value: Optional[datetime.datetime]) -> None:
+ if value:
+ date_str = _format_datetime_utc(value)
+ self._set_single_value(XMP_NAMESPACE, "MetadataDate", date_str)
+ else:
+ self._set_single_value(XMP_NAMESPACE, "MetadataDate", None)
+
+ @property
+ def xmp_creator_tool(self) -> Optional[str]:
+ """The name of the first known tool used to create the resource."""
+ return self._get_single_value(XMP_NAMESPACE, "CreatorTool")
+
+ @xmp_creator_tool.setter
+ def xmp_creator_tool(self, value: Optional[str]) -> None:
+ self._set_single_value(XMP_NAMESPACE, "CreatorTool", value)
+
+ @property
+ def xmpmm_document_id(self) -> Optional[str]:
+ """The common identifier for all versions and renditions of this resource."""
+ return self._get_single_value(XMPMM_NAMESPACE, "DocumentID")
+
+ @xmpmm_document_id.setter
+ def xmpmm_document_id(self, value: Optional[str]) -> None:
+ self._set_single_value(XMPMM_NAMESPACE, "DocumentID", value)
+
+ @property
+ def xmpmm_instance_id(self) -> Optional[str]:
+ """An identifier for a specific incarnation of a document, updated each time a file is saved."""
+ return self._get_single_value(XMPMM_NAMESPACE, "InstanceID")
+
+ @xmpmm_instance_id.setter
+ def xmpmm_instance_id(self, value: Optional[str]) -> None:
+ self._set_single_value(XMPMM_NAMESPACE, "InstanceID", value)
+
+ @property
+ def pdfaid_part(self) -> Optional[str]:
+ """The part of the PDF/A standard that the document conforms to (e.g., 1, 2, 3)."""
+ return self._get_single_value(PDFAID_NAMESPACE, "part")
+
+ @pdfaid_part.setter
+ def pdfaid_part(self, value: Optional[str]) -> None:
+ self._set_single_value(PDFAID_NAMESPACE, "part", value)
+
+ @property
+ def pdfaid_conformance(self) -> Optional[str]:
+ """The conformance level within the PDF/A standard (e.g., 'A', 'B', 'U')."""
+ return self._get_single_value(PDFAID_NAMESPACE, "conformance")
+
+ @pdfaid_conformance.setter
+ def pdfaid_conformance(self, value: Optional[str]) -> None:
+ self._set_single_value(PDFAID_NAMESPACE, "conformance", value)
+
+ @property
+ def custom_properties(self) -> dict[Any, Any]:
+ """
+ Retrieve custom metadata properties defined in the undocumented pdfx
+ metadata schema.
+
+ Returns:
+ A dictionary of key/value items for custom metadata properties.
+
+ """
+ if not hasattr(self, "_custom_properties"):
+ self._custom_properties = {}
+ for node in self.get_nodes_in_namespace("", PDFX_NAMESPACE):
+ key = node.localName
+ while True:
+ # see documentation about PDFX_NAMESPACE earlier in file
+ idx = key.find("\u2182")
+ if idx == -1:
+ break
+ key = (
+ key[:idx]
+ + chr(int(key[idx + 1 : idx + 5], base=16))
+ + key[idx + 5 :]
+ )
+ if node.nodeType == node.ATTRIBUTE_NODE:
+ value = node.nodeValue
+ else:
+ value = self._get_text(node)
+ self._custom_properties[key] = value
+ return self._custom_properties
+
+ def _get_or_create_description(self, about_uri: str = "") -> XmlElement:
+ """Get or create an rdf:Description element with the given about URI."""
+ for desc in self.rdf_root.getElementsByTagNameNS(RDF_NAMESPACE, "Description"):
+ if desc.getAttributeNS(RDF_NAMESPACE, "about") == about_uri:
+ return desc
+
+ doc = self.rdf_root.ownerDocument
+ if doc is None:
+ raise XmpDocumentError("XMP Document is None")
+ desc = doc.createElementNS(RDF_NAMESPACE, "rdf:Description")
+ desc.setAttributeNS(RDF_NAMESPACE, "rdf:about", about_uri)
+ self.rdf_root.appendChild(desc)
+ return desc
+
+ def _clear_cache_entry(self, namespace: str, name: str) -> None:
+ """Remove a cached value for a given namespace/name if present."""
+ ns_cache = self.cache.get(namespace)
+ if ns_cache and name in ns_cache:
+ del ns_cache[name]
+
+ def _set_single_value(self, namespace: str, name: str, value: Optional[str]) -> None:
+ """Set or remove a single metadata value."""
+ self._clear_cache_entry(namespace, name)
+ desc = self._get_or_create_description()
+
+ existing_elements = list(desc.getElementsByTagNameNS(namespace, name))
+ for elem in existing_elements:
+ desc.removeChild(elem)
+
+ if existing_attr := desc.getAttributeNodeNS(namespace, name):
+ desc.removeAttributeNode(existing_attr)
+
+ if value is not None:
+ doc = self.rdf_root.ownerDocument
+ if doc is None:
+ raise XmpDocumentError("XMP Document is None")
+ prefix = self._get_namespace_prefix(namespace)
+ elem = doc.createElementNS(namespace, f"{prefix}:{name}")
+ text_node = doc.createTextNode(str(value))
+ elem.appendChild(text_node)
+ desc.appendChild(elem)
+
+ self._update_stream()
+
+ def _set_bag_values(self, namespace: str, name: str, values: Optional[list[str]]) -> None:
+ """Set or remove bag values (unordered array)."""
+ self._clear_cache_entry(namespace, name)
+ desc = self._get_or_create_description()
+
+ existing_elements = list(desc.getElementsByTagNameNS(namespace, name))
+ for elem in existing_elements:
+ desc.removeChild(elem)
+
+ if values:
+ doc = self.rdf_root.ownerDocument
+ if doc is None:
+ raise XmpDocumentError("XMP Document is None")
+ prefix = self._get_namespace_prefix(namespace)
+ elem = doc.createElementNS(namespace, f"{prefix}:{name}")
+ bag = doc.createElementNS(RDF_NAMESPACE, "rdf:Bag")
+
+ for value in values:
+ li = doc.createElementNS(RDF_NAMESPACE, "rdf:li")
+ text_node = doc.createTextNode(str(value))
+ li.appendChild(text_node)
+ bag.appendChild(li)
+
+ elem.appendChild(bag)
+ desc.appendChild(elem)
+
+ self._update_stream()
+
+ def _set_seq_values(self, namespace: str, name: str, values: Optional[list[str]]) -> None:
+ """Set or remove sequence values (ordered array)."""
+ self._clear_cache_entry(namespace, name)
+ desc = self._get_or_create_description()
+
+ existing_elements = list(desc.getElementsByTagNameNS(namespace, name))
+ for elem in existing_elements:
+ desc.removeChild(elem)
+
+ if values:
+ doc = self.rdf_root.ownerDocument
+ if doc is None:
+ raise XmpDocumentError("XMP Document is None")
+ prefix = self._get_namespace_prefix(namespace)
+ elem = doc.createElementNS(namespace, f"{prefix}:{name}")
+ seq = doc.createElementNS(RDF_NAMESPACE, "rdf:Seq")
+
+ for value in values:
+ li = doc.createElementNS(RDF_NAMESPACE, "rdf:li")
+ text_node = doc.createTextNode(str(value))
+ li.appendChild(text_node)
+ seq.appendChild(li)
+
+ elem.appendChild(seq)
+ desc.appendChild(elem)
+
+ self._update_stream()
+
+ def _set_langalt_values(self, namespace: str, name: str, values: Optional[dict[str, str]]) -> None:
+ """Set or remove language alternative values."""
+ self._clear_cache_entry(namespace, name)
+ desc = self._get_or_create_description()
+
+ existing_elements = list(desc.getElementsByTagNameNS(namespace, name))
+ for elem in existing_elements:
+ desc.removeChild(elem)
+
+ if values:
+ doc = self.rdf_root.ownerDocument
+ if doc is None:
+ raise XmpDocumentError("XMP Document is None")
+ prefix = self._get_namespace_prefix(namespace)
+ elem = doc.createElementNS(namespace, f"{prefix}:{name}")
+ alt = doc.createElementNS(RDF_NAMESPACE, "rdf:Alt")
+
+ for lang, value in values.items():
+ li = doc.createElementNS(RDF_NAMESPACE, "rdf:li")
+ li.setAttribute("xml:lang", lang)
+ text_node = doc.createTextNode(str(value))
+ li.appendChild(text_node)
+ alt.appendChild(li)
+
+ elem.appendChild(alt)
+ desc.appendChild(elem)
+
+ self._update_stream()
+
+ def _get_namespace_prefix(self, namespace: str) -> str:
+ """Get the appropriate namespace prefix for a given namespace URI."""
+ return _NAMESPACE_PREFIX_MAP.get(namespace, "unknown")
+
+ def _update_stream(self) -> None:
+ """Update the stream with the current XML content."""
+ doc = self.rdf_root.ownerDocument
+ if doc is None:
+ raise XmpDocumentError("XMP Document is None")
+
+ xml_data = doc.toxml(encoding="utf-8")
+ self.stream.set_data(xml_data)