apdf 1.3__tar.gz → 1.4__tar.gz

{apdf-1.3 → apdf-1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: apdf
-Version: 1.3
+Version: 1.4
 Summary: Meet another powerful PDF editing tool, designed to modify raw PDF data in hexadecimal format as well as Unicode text.
 Author: Abodx9
 License-Expression: MIT

apdf-1.4/apdf/cli.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+import argparse
+import sys
+from importlib.metadata import PackageNotFoundError, version
+from typing import Sequence
+from apdf.engine import replace_pdf_text_detailed
+from apdf.exceptions import PdfReplacementError
+from apdf.utils import _c, _supports_color, _BLUE, _BOLD, _CYAN, _DIM, _GRAY, _GREEN, _MAGENTA, _RED, _YELLOW
+
+def _installed_version() -> str:
+    try:
+        return version('apdf')
+    except PackageNotFoundError:
+        return '1.0'
+_BANNER = '\n_______       __________________________\n___    |      ___  __ \\__  __ ' + '\\__  ____/\n__  /| |__' + '______  /_/ /_  / / /_  /_    \n_  ___ |/_____/  ____/_  /_/ /_  __/    \n/_/  |_|      /_/     /_____/ /_/   \n   \n'
+
+def _print_banner() -> None:
+    _luspywqkvmvrcd = _installed_version()
+    if _supports_color():
+        _bnvotxiqadqonq = _BANNER.strip('\n').splitlines()
+        _vmkdofpuauzemf = [_RED, _RED, _BLUE, _BLUE, _CYAN]
+        for _dxghtiudepbhsk, _rfgkkppfsaibby in enumerate(_bnvotxiqadqonq):
+            _spscwgxozidwla = _vmkdofpuauzemf[_dxghtiudepbhsk] if _dxghtiudepbhsk < len(_vmkdofpuauzemf) else _CYAN
+            print(_c(_rfgkkppfsaibby, _spscwgxozidwla, _BOLD), file=sys.stderr)
+    else:
+        print(_BANNER.strip('\n'), file=sys.stderr)
+    _tdpoveqqavadxr = _c('  Low-level P' + 'DF Text Replace' + 'r', _DIM)
+    _rnhharzhosuggk = _c(f' v{_luspywqkvmvrcd} ', _BOLD, _MAGENTA)
+    _yrmhryoociptmz = _c(' by ' + 'Abodx9', _YELLOW, _BOLD)
+    print(f'{_tdpoveqqavadxr}{_rnhharzhosuggk}{_yrmhryoociptmz}\n', file=sys.stderr)
+    print(_c('  ' + '─' * 52, _GRAY), file=sys.stderr)
+    print(file=sys.stderr)
+
+def _parse_replacements(values: Sequence[str]) -> dict[str, str]:
+    _vpoyhgaaogdcrf: dict[str, str] = {}
+    for _cjyjvzbuqivfrb in values:
+        if '=' not in _cjyjvzbuqivfrb:
+            raise ValueError('-' + 'r requires OLD=NEW')
+        old, new = _cjyjvzbuqivfrb.split('=', 1)
+        if not old:
+            raise ValueError('OL' + 'D cannot' + ' be empt' + 'y')
+        _vpoyhgaaogdcrf[old] = new
+    return _vpoyhgaaogdcrf
+
+def _parse_pages(value: str | None) -> set[int] | None:
+    if value is None:
+        return None
+    pages: set[int] = set()
+    for _trsktuknqeatlq in value.split(','):
+        _tzxijeernzifec = _trsktuknqeatlq.strip()
+        if not _tzxijeernzifec:
+            raise ValueError('-' + 'p contains an ' + 'empty page' + ' number')
+        if '-' in _tzxijeernzifec:
+            _jcgcxqgvrkiuug = [piece.strip() for piece in _tzxijeernzifec.split('-')]
+            if len(_jcgcxqgvrkiuug) != 2 or not all((piece.isdigit() for piece in _jcgcxqgvrkiuug)):
+                raise ValueError(f'invalid page range: {_tzxijeernzifec!r}')
+            start, _bqgczixucnkfim = map(int, _jcgcxqgvrkiuug)
+            if start < 1 or _bqgczixucnkfim < 1:
+                raise ValueError('page' + ' ' + 'numbers must be 1 or greater')
+            if start > _bqgczixucnkfim:
+                raise ValueError(f'page range must be ascending: {_tzxijeernzifec!r}')
+            pages.update(range(start, _bqgczixucnkfim + 1))
+        else:
+            if not _tzxijeernzifec.isdigit():
+                raise ValueError(f'invalid page number: {_tzxijeernzifec!r}')
+            _mhcnzbjhwlcbnx = int(_tzxijeernzifec)
+            if _mhcnzbjhwlcbnx < 1:
+                raise ValueError('page number' + 's' + ' must be 1 or grea' + 'ter')
+            pages.add(_mhcnzbjhwlcbnx)
+    return pages
+
+def main(argv: Sequence[str] | None=None) -> int:
+    _print_banner()
+    if argv is None:
+        argv = sys.argv[1:]
+    _azqupustegpfle = argparse.ArgumentParser(description='Replace Unicode and' + ' Hex text directly in PDF ' + 'content stream' + 's.')
+    _azqupustegpfle.add_argument('input', help='Inp' + 'ut PDF')
+    _azqupustegpfle.add_argument('output', nargs='?', default='output.pdf', help='Outpu' + 't PDF')
+    _azqupustegpfle.add_argument('-r', action='append', default=[], metavar='OLD=NEW', dest='replace', help='Replac' + 'e: Unicode replacement; may be sup' + 'plied more' + ' than once')
+    _azqupustegpfle.add_argument('-p', metavar='PAGES', dest='pages', help='Pages to ed' + 'it, e.g' + '. 2, 2,3,4, or 1-5; defaults to all pages')
+    _azqupustegpfle.add_argument('-nopa', action='store_true', dest='no_preserve_advance', help='No preserve advance: Do not comp' + 'e' + 'nsate TJ widths after replacements')
+    _azqupustegpfle.add_argument('-s', action='store_true', dest='strict', help='Strict: Fail if text is m' + 'issing or the selected font' + ' cannot encode it')
+    _azqupustegpfle.add_argument('-ff', metavar='FONT.ttf', dest='fallback_font', help="Fallback font: TrueType font to embed when the PDF's sub" + 'set font lacks a glyph; def' + 'aults to a commo' + 'n system sans-serif font')
+    _azqupustegpfle.add_argument('-no-ff', action='store_true', dest='no_font_fallback', help='No font ' + 'f' + 'allback: Reject missing glyphs inste' + 'ad of embedding a fallback font')
+    _wpxvtcvrscmlcr = _azqupustegpfle.parse_args(argv)
+    try:
+        replacements = _parse_replacements(_wpxvtcvrscmlcr.replace)
+        pages = _parse_pages(_wpxvtcvrscmlcr.pages)
+        if not replacements:
+            _azqupustegpfle.error('provide' + ' a' + 't least ' + 'one -r OLD=NEW')
+        _udobssarculrcm = replace_pdf_text_detailed(_wpxvtcvrscmlcr.input, _wpxvtcvrscmlcr.output, replacements, preserve_advance=not _wpxvtcvrscmlcr.no_preserve_advance, strict=_wpxvtcvrscmlcr.strict, fallback_font=_wpxvtcvrscmlcr.fallback_font, font_fallback=not _wpxvtcvrscmlcr.no_font_fallback, pages=pages)
+    except (OSError, PdfReplacementError, ValueError) as _gzcgcunigakueg:
+        _azqupustegpfle.exit(2, _c(f'error: {_gzcgcunigakueg}\n', _RED))
+    except Exception as _gzcgcunigakueg:
+        _azqupustegpfle.exit(2, _c(f'error: An unexpected error occurred: {type(_gzcgcunigakueg).__name__}: {_gzcgcunigakueg}\n', _RED))
+    print(_c(f'Replaced {_udobssarculrcm.replacements} occurrence(s) in {_udobssarculrcm.changed_streams}/{_udobssarculrcm.scanned_streams} stream(s) in {_udobssarculrcm.elapsed_seconds:.3f}s.', _GREEN))
+    if _udobssarculrcm.missing:
+        print(_c('Not f' + 'ound: ' + ', '.join((repr(value) for value in _udobssarculrcm.missing)), _RED))
+    if _udobssarculrcm.encoding_failures:
+        print(_c(f'Skipped {len(_udobssarculrcm.encoding_failures)} unencodable replacement(s).', _RED))
+    print(_c(f'Saved: {_wpxvtcvrscmlcr.output}', _GREEN, _BOLD))
+    return 0

{apdf-1.3 → apdf-1.4}/apdf/codec.py

@@ -32,19 +32,19 @@ class FontCodec:
 
     @property
     def description(self) -> str:
-        _dtonbtsnepubbb = str(self.pdf_font.get('/Subtype', 'unknown'))
-        _abqsmvngjipqzp = str(self.pdf_font.get('/BaseFont', 'unknown'))
-        return f'{self.resource_name} {_dtonbtsnepubbb} {_abqsmvngjipqzp}'
+        _fwisjtxoozvyes = str(self.pdf_font.get('/Subtype', 'unknown'))
+        _sdsulzvqjnzjej = str(self.pdf_font.get('/BaseFont', 'unknown'))
+        return f'{self.resource_name} {_fwisjtxoozvyes} {_sdsulzvqjnzjej}'
 
     def _build_inverse_maps(self) -> None:
-        for _cpszezpkxhlcgm, _rrrtuzutsrcpaf in self.font.character_map.items():
-            if isinstance(_cpszezpkxhlcgm, str) and isinstance(_rrrtuzutsrcpaf, str):
-                self._unicode_to_intermediate.setdefault(_rrrtuzutsrcpaf, _cpszezpkxhlcgm)
+        for _gtlnoasxovzwkd, _okilniypkixbng in self.font.character_map.items():
+            if isinstance(_gtlnoasxovzwkd, str) and isinstance(_okilniypkixbng, str):
+                self._unicode_to_intermediate.setdefault(_okilniypkixbng, _gtlnoasxovzwkd)
         encoding = self.font.encoding
         if isinstance(encoding, dict):
-            for _mijbpyiwaochif, _nnbahipgbrogqf in encoding.items():
-                if isinstance(_mijbpyiwaochif, int) and 0 <= _mijbpyiwaochif <= 255 and isinstance(_nnbahipgbrogqf, str):
-                    self._intermediate_to_bytes.setdefault(_nnbahipgbrogqf, bytes((_mijbpyiwaochif,)))
+            for _gjilmuozklwhre, _grstvsghjoxrnq in encoding.items():
+                if isinstance(_gjilmuozklwhre, int) and 0 <= _gjilmuozklwhre <= 255 and isinstance(_grstvsghjoxrnq, str):
+                    self._intermediate_to_bytes.setdefault(_grstvsghjoxrnq, bytes((_gjilmuozklwhre,)))
 
     def _load_glyph_inventory(self) -> None:
         encoding = _deref(self.pdf_font.get('/Encoding'))
@@ -97,10 +97,10 @@ class FontCodec:
     def _gid_for_cid(self, cid: int) -> int:
         if self._cid_to_gid_bytes is None:
             return cid
-        _dqxyefsqqlowdi = cid * 2
-        if _dqxyefsqqlowdi + 2 > len(self._cid_to_gid_bytes):
+        _jatgoccybumvbw = cid * 2
+        if _jatgoccybumvbw + 2 > len(self._cid_to_gid_bytes):
             return 0
-        return int.from_bytes(self._cid_to_gid_bytes[_dqxyefsqqlowdi:_dqxyefsqqlowdi + 2], 'big')
+        return int.from_bytes(self._cid_to_gid_bytes[_jatgoccybumvbw:_jatgoccybumvbw + 2], 'big')
 
     def _glyph_is_drawable(self, gid: int) -> bool:
         cached = self._drawable_glyphs.get(gid)
@@ -138,55 +138,55 @@ class FontCodec:
         if not isinstance(encoding, str):
             return
         try:
-            _rzcdzoakbxyqft = raw.decode(encoding, errors='strict')
+            _ggkrhwxuukljqr = raw.decode(encoding, errors='strict')
         except (LookupError, UnicodeError):
             return
-        for _pozbahvroafvai in _rzcdzoakbxyqft:
-            _uxqxdjmxeovyve = self.font.character_map.get(_pozbahvroafvai, _pozbahvroafvai)
-            if _uxqxdjmxeovyve and all((character.isspace() for character in _uxqxdjmxeovyve)):
+        for _qyrzffrmdzxhez in _ggkrhwxuukljqr:
+            _unjmlnhyycmucn = self.font.character_map.get(_qyrzffrmdzxhez, _qyrzffrmdzxhez)
+            if _unjmlnhyycmucn and all((character.isspace() for character in _unjmlnhyycmucn)):
                 continue
-            _fhykuxrvpsrlom = ord(_pozbahvroafvai)
-            _txhbexxrxmbeky = self._gid_for_cid(_fhykuxrvpsrlom)
-            if not self._glyph_is_drawable(_txhbexxrxmbeky):
-                _hwpecwftjyvqmd = ' '.join((f'U+{ord(character):04X}' for character in _uxqxdjmxeovyve)) or f'CID {_fhykuxrvpsrlom}'
-                raise FontEncodingError(f'{self.description} embedded subset has no drawable glyph for {_hwpecwftjyvqmd} (CID {_fhykuxrvpsrlom}, GID {_txhbexxrxmbeky})')
+            _yfptaenaqsasji = ord(_qyrzffrmdzxhez)
+            _ubvtskzofhgavi = self._gid_for_cid(_yfptaenaqsasji)
+            if not self._glyph_is_drawable(_ubvtskzofhgavi):
+                _egiaintnwxlucm = ' '.join((f'U+{ord(character):04X}' for character in _unjmlnhyycmucn)) or f'CID {_yfptaenaqsasji}'
+                raise FontEncodingError(f'{self.description} embedded subset has no drawable glyph for {_egiaintnwxlucm} (CID {_yfptaenaqsasji}, GID {_ubvtskzofhgavi})')
 
     def _glyph_name_for_code(self, code: int) -> str | None:
         if code in self._difference_glyphs:
             return self._difference_glyphs[code]
         encoding = self.font.encoding
         if isinstance(encoding, dict):
-            _xdjugpuibuolde = encoding.get(code)
-            if isinstance(_xdjugpuibuolde, str) and len(_xdjugpuibuolde) == 1:
-                return UV2AGL.get(ord(_xdjugpuibuolde))
-        _ipxmujfdbqmznv = str(self.pdf_font.get('/Encoding', ''))
-        codec = {'/WinAnsiEncoding': 'cp1252', '/MacRomanEncoding': 'mac_roman'}.get(_ipxmujfdbqmznv, 'latin-1')
+            _wnpbluhafmlfxt = encoding.get(code)
+            if isinstance(_wnpbluhafmlfxt, str) and len(_wnpbluhafmlfxt) == 1:
+                return UV2AGL.get(ord(_wnpbluhafmlfxt))
+        _msnuxxjktrptvl = str(self.pdf_font.get('/Encoding', ''))
+        codec = {'/WinAnsiEncoding': 'cp1252', '/MacRomanEncoding': 'mac_roman'}.get(_msnuxxjktrptvl, 'latin-1')
         try:
-            _yhbgyxeyqreqah = bytes((code,)).decode(codec)
+            _pattpbonwpdlia = bytes((code,)).decode(codec)
         except (UnicodeDecodeError, LookupError):
             return None
-        return UV2AGL.get(ord(_yhbgyxeyqreqah))
+        return UV2AGL.get(ord(_pattpbonwpdlia))
 
     def _validate_embedded_glyphs(self, raw: bytes, visible: str) -> None:
-        _aojpgqqhfkrpwi = str(self.pdf_font.get('/Subtype', ''))
-        if _aojpgqqhfkrpwi == '/Type3':
+        _vqsenaebmchtxj = str(self.pdf_font.get('/Subtype', ''))
+        if _vqsenaebmchtxj == '/Type3':
             encoding = self.font.encoding
             if isinstance(encoding, dict):
-                for _gcjnhinzjlcpmh in raw:
-                    _mnkuifxpsuezme = encoding.get(_gcjnhinzjlcpmh, chr(_gcjnhinzjlcpmh))
-                    if _mnkuifxpsuezme not in self.font.character_map:
-                        raise FontEncodingError(f'{self.description} has no explicit Type3 mapping for character code 0x{_gcjnhinzjlcpmh:02X}')
+                for _pflflsknediqaw in raw:
+                    _laybgcolzwxzyj = encoding.get(_pflflsknediqaw, chr(_pflflsknediqaw))
+                    if _laybgcolzwxzyj not in self.font.character_map:
+                        raise FontEncodingError(f'{self.description} has no explicit Type3 mapping for character code 0x{_pflflsknediqaw:02X}')
             if self.decode(raw) != visible:
                 raise FontEncodingError(f'{self.description} has no reversible glyph mapping for {visible!r}')
             return
-        if _aojpgqqhfkrpwi == '/Type0':
+        if _vqsenaebmchtxj == '/Type0':
             self._validate_type0_glyph_outlines(raw)
         if self._embedded_glyphs is not None:
             missing: list[str] = []
-            for _gcjnhinzjlcpmh in raw:
-                _vsecktyjcjrjfy = self._glyph_name_for_code(_gcjnhinzjlcpmh)
-                if _vsecktyjcjrjfy and _vsecktyjcjrjfy not in self._embedded_glyphs:
-                    missing.append(_vsecktyjcjrjfy)
+            for _pflflsknediqaw in raw:
+                _jctlgvfwnicjwx = self._glyph_name_for_code(_pflflsknediqaw)
+                if _jctlgvfwnicjwx and _jctlgvfwnicjwx not in self._embedded_glyphs:
+                    missing.append(_jctlgvfwnicjwx)
             if missing:
                 names = ', '.join(sorted(set(missing)))
                 raise FontEncodingError(f'{self.description} embedded subset lacks glyph(s): {names}')
@@ -197,63 +197,63 @@ class FontCodec:
         encoding = self.font.encoding
         if isinstance(encoding, str):
             try:
-                _prjxvllsrsceqe = raw.decode(encoding, errors='surrogatepass')
+                _tpaceezyldticp = raw.decode(encoding, errors='surrogatepass')
             except (LookupError, UnicodeError):
-                _vvtbwoypfiegky = 'utf-16-be' if len(raw) % 2 == 0 else 'latin-1'
-                _prjxvllsrsceqe = raw.decode(_vvtbwoypfiegky, errors='replace')
+                _jhcxvfjfjxrcfa = 'utf-16-be' if len(raw) % 2 == 0 else 'latin-1'
+                _tpaceezyldticp = raw.decode(_jhcxvfjfjxrcfa, errors='replace')
         else:
-            _prjxvllsrsceqe = ''.join((encoding.get(byte, chr(byte)) for byte in raw))
-        return ''.join((self.font.character_map.get(character, character) for character in _prjxvllsrsceqe))
+            _tpaceezyldticp = ''.join((encoding.get(byte, chr(byte)) for byte in raw))
+        return ''.join((self.font.character_map.get(character, character) for character in _tpaceezyldticp))
 
     @staticmethod
     def _greedy_map(text: str, mapping: Mapping[str, str]) -> str:
         if not mapping:
             return text
-        _cfguxjxbjcwaau = sorted(mapping, key=len, reverse=True)
+        _cforlarevilftd = sorted(mapping, key=len, reverse=True)
         output: list[str] = []
-        _qjbwwztaspnkuz = 0
-        while _qjbwwztaspnkuz < len(text):
-            for key in _cfguxjxbjcwaau:
-                if key and text.startswith(key, _qjbwwztaspnkuz):
+        _zzusctkjdsatuj = 0
+        while _zzusctkjdsatuj < len(text):
+            for key in _cforlarevilftd:
+                if key and text.startswith(key, _zzusctkjdsatuj):
                     output.append(mapping[key])
-                    _qjbwwztaspnkuz += len(key)
+                    _zzusctkjdsatuj += len(key)
                     break
             else:
-                output.append(text[_qjbwwztaspnkuz])
-                _qjbwwztaspnkuz += 1
+                output.append(text[_zzusctkjdsatuj])
+                _zzusctkjdsatuj += 1
         return ''.join(output)
 
     def encode(self, visible: str) -> bytes:
-        _bwcwwxglrozrgj = self._greedy_map(visible, self._unicode_to_intermediate)
+        _smuyjzjannqguq = self._greedy_map(visible, self._unicode_to_intermediate)
         encoding = self.font.encoding
         if isinstance(encoding, str):
             try:
-                _zwmhatqlzblobv = _bwcwwxglrozrgj.encode(encoding, errors='strict')
-            except (LookupError, UnicodeError) as _dbmfrervtovraa:
-                raise FontEncodingError(f'{self.description} cannot encode {visible!r}') from _dbmfrervtovraa
-            self._validate_embedded_glyphs(_zwmhatqlzblobv, visible)
-            return _zwmhatqlzblobv
-        _habhwtgwcviujd = sorted(self._intermediate_to_bytes, key=len, reverse=True)
-        _qeoxigncjzbjdy = bytearray()
-        _plyeupfjypdihj = 0
-        while _plyeupfjypdihj < len(_bwcwwxglrozrgj):
-            for key in _habhwtgwcviujd:
-                if key and _bwcwwxglrozrgj.startswith(key, _plyeupfjypdihj):
-                    _qeoxigncjzbjdy.extend(self._intermediate_to_bytes[key])
-                    _plyeupfjypdihj += len(key)
+                _vllohhdgfteusd = _smuyjzjannqguq.encode(encoding, errors='strict')
+            except (LookupError, UnicodeError) as _ewqpmknbgmswnz:
+                raise FontEncodingError(f'{self.description} cannot encode {visible!r}') from _ewqpmknbgmswnz
+            self._validate_embedded_glyphs(_vllohhdgfteusd, visible)
+            return _vllohhdgfteusd
+        _pdgwbgnnwdjilr = sorted(self._intermediate_to_bytes, key=len, reverse=True)
+        _vgbbptfknztcnt = bytearray()
+        _vdtdodqdcncmhs = 0
+        while _vdtdodqdcncmhs < len(_smuyjzjannqguq):
+            for key in _pdgwbgnnwdjilr:
+                if key and _smuyjzjannqguq.startswith(key, _vdtdodqdcncmhs):
+                    _vgbbptfknztcnt.extend(self._intermediate_to_bytes[key])
+                    _vdtdodqdcncmhs += len(key)
                     break
             else:
-                raise FontEncodingError(f'{self.description} cannot encode character {_bwcwwxglrozrgj[_plyeupfjypdihj]!r} in {visible!r}')
-        _zwmhatqlzblobv = bytes(_qeoxigncjzbjdy)
-        self._validate_embedded_glyphs(_zwmhatqlzblobv, visible)
-        return _zwmhatqlzblobv
+                raise FontEncodingError(f'{self.description} cannot encode character {_smuyjzjannqguq[_vdtdodqdcncmhs]!r} in {visible!r}')
+        _vllohhdgfteusd = bytes(_vgbbptfknztcnt)
+        self._validate_embedded_glyphs(_vllohhdgfteusd, visible)
+        return _vllohhdgfteusd
 
     def width(self, visible: str) -> float:
         try:
-            _bvfcdxkscamzsr = self._greedy_map(visible, self._unicode_to_intermediate)
-            _ctwrdofcwpavtu = self.font.character_widths
-            default = float(_ctwrdofcwpavtu.get('default', 0.0))
-            return sum((float(_ctwrdofcwpavtu.get(character, default)) for character in _bvfcdxkscamzsr))
+            _iqaaghkxvvufsn = self._greedy_map(visible, self._unicode_to_intermediate)
+            _tbcdhpmrdrmcet = self.font.character_widths
+            default = float(_tbcdhpmrdrmcet.get('default', 0.0))
+            return sum((float(_tbcdhpmrdrmcet.get(character, default)) for character in _iqaaghkxvvufsn))
         except Exception:
             return 0.0
 

apdf-1.4/apdf/engine.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+import os
+import sys
+import tempfile
+import time
+from pathlib import Path
+from typing import Any, Iterable, Mapping, Sequence
+from pypdf import PdfReader, PdfWriter
+from pypdf.errors import DependencyError
+from pypdf.generic import ArrayObject, ContentStream, DictionaryObject, NameObject, StreamObject
+from apdf.codec import _font_codecs
+from apdf.exceptions import PdfReplacementError, PdfDependencyError, PdfPermissionError, PdfFileNotFoundError
+from apdf.fallback import FallbackFontRegistry
+from apdf.models import Replacement, ReplacementReport
+from apdf.operations import _rewrite_operations
+from apdf.utils import _deref, _object_key, _c, _BLUE
+
+def _set_decoded_stream_data(stream: StreamObject, data: bytes) -> None:
+    try:
+        stream.set_data(data)
+    except Exception as _uzqxnhhwivanmc:
+        raise PdfReplacementError('Cannot r' + 'ewrite a content stream w' + 'ith its current PD' + 'F filters') from _uzqxnhhwivanmc
+
+def _rewrite_stream(stream: StreamObject, pdf: PdfWriter, resources: Any, replacements: Sequence[Replacement], preserve_advance: bool, report: ReplacementReport, matched: set[str], fallback_registry: FallbackFontRegistry, page_number: int) -> None:
+    report.scanned_streams += 1
+    content = ContentStream(stream, pdf)
+    operations = content.operations
+    codecs = _font_codecs(resources)
+    count = _rewrite_operations(operations, codecs, replacements, preserve_advance, report, matched, page_number, lambda original, size, visible: fallback_registry.resolve(original, size, visible, resources))
+    if count:
+        content.operations = operations
+        _set_decoded_stream_data(stream, content.get_data())
+        report.changed_streams += 1
+
+def _content_streams(owner: Any) -> Iterable[StreamObject]:
+    _avprdqgqwmnmeg = _deref(owner.get('/Contents'))
+    if _avprdqgqwmnmeg is None:
+        return
+    if isinstance(_avprdqgqwmnmeg, (list, ArrayObject)):
+        for _txyretiadsatpw in _avprdqgqwmnmeg:
+            _pqbfxcufmqdpgp = _deref(_txyretiadsatpw)
+            if isinstance(_pqbfxcufmqdpgp, StreamObject):
+                yield _pqbfxcufmqdpgp
+    elif isinstance(_avprdqgqwmnmeg, StreamObject):
+        yield _avprdqgqwmnmeg
+
+def _shallow_stream_clone(stream: StreamObject, writer: PdfWriter) -> Any:
+    _foypyflaryhsuf = type(stream)()
+    for key, _qidrprqgtxbosn in stream.items():
+        if str(key) != '/Length':
+            _foypyflaryhsuf[key] = _qidrprqgtxbosn
+    _foypyflaryhsuf._data = stream._data
+    return writer._add_object(_foypyflaryhsuf)
+
+def _isolate_resources(resources: Any, writer: PdfWriter, forms: dict[tuple[Any, ...], Any]) -> DictionaryObject:
+    _kwpmlbkldqrhil = _deref(resources)
+    _rimlebyulqzort = DictionaryObject()
+    if not _kwpmlbkldqrhil:
+        return _rimlebyulqzort
+    for key, _zzmtqrfztivzcm in _kwpmlbkldqrhil.items():
+        _rimlebyulqzort[key] = _zzmtqrfztivzcm
+    _dyjjieirnhpvnd = _deref(_kwpmlbkldqrhil.get('/Font'))
+    if _dyjjieirnhpvnd is not None:
+        _rimlebyulqzort[NameObject('/Font')] = DictionaryObject(_dyjjieirnhpvnd.items())
+    _vypkqemsdptblt = _deref(_kwpmlbkldqrhil.get('/XObject'))
+    if _vypkqemsdptblt is not None:
+        _mjkzsoxjapafpa = DictionaryObject()
+        _rimlebyulqzort[NameObject('/XObject')] = _mjkzsoxjapafpa
+        for name, _cikijagztdgvdn in _vypkqemsdptblt.items():
+            _gjkfrcethbpnvf = _deref(_cikijagztdgvdn)
+            if not isinstance(_gjkfrcethbpnvf, StreamObject) or _gjkfrcethbpnvf.get('/Subtype') != '/Form':
+                _mjkzsoxjapafpa[name] = _cikijagztdgvdn
+                continue
+            key = _object_key(_gjkfrcethbpnvf)
+            _ajdwclzfwnexwg = forms.get(key)
+            if _ajdwclzfwnexwg is None:
+                _ajdwclzfwnexwg = _shallow_stream_clone(_gjkfrcethbpnvf, writer)
+                forms[key] = _ajdwclzfwnexwg
+                _cvfbdeeeptkbjw = _deref(_ajdwclzfwnexwg)
+                _tglkbhlmzsvdoe = _gjkfrcethbpnvf.get('/Resources')
+                if _tglkbhlmzsvdoe is not None:
+                    _cvfbdeeeptkbjw[NameObject('/Resources')] = _isolate_resources(_tglkbhlmzsvdoe, writer, forms)
+            _mjkzsoxjapafpa[name] = _ajdwclzfwnexwg
+    return _rimlebyulqzort
+
+def _isolate_contents(contents: Any, writer: PdfWriter) -> Any:
+    _jrimzwzmmvxizi = _deref(contents)
+    if isinstance(_jrimzwzmmvxizi, (list, ArrayObject)):
+        _lbcempgxkgbhvm = ArrayObject()
+        for _xzhtzaunhnlubj in _jrimzwzmmvxizi:
+            _efisgocfxjygnk = _deref(_xzhtzaunhnlubj)
+            _lbcempgxkgbhvm.append(_shallow_stream_clone(_efisgocfxjygnk, writer) if isinstance(_efisgocfxjygnk, StreamObject) else _xzhtzaunhnlubj)
+        return _lbcempgxkgbhvm
+    if isinstance(_jrimzwzmmvxizi, StreamObject):
+        return _shallow_stream_clone(_jrimzwzmmvxizi, writer)
+    return contents
+
+def _isolate_selected_page(page: Any, writer: PdfWriter) -> None:
+    _hynfvpnwoqktzv = page.get('/Contents')
+    if _hynfvpnwoqktzv is not None:
+        page[NameObject('/Contents')] = _isolate_contents(_hynfvpnwoqktzv, writer)
+    _lpvstzdynixypx = page.get('/Resources')
+    if _lpvstzdynixypx is not None:
+        page[NameObject('/Resources')] = _isolate_resources(_lpvstzdynixypx, writer, {})
+
+def _selected_page_numbers(pages: Iterable[int] | int | None, page_count: int) -> set[int]:
+    if pages is None:
+        return set(range(1, page_count + 1))
+    if isinstance(pages, bool):
+        raise ValueError('pages must contain page numbe' + 'rs, not a boolean')
+    if isinstance(pages, int):
+        _dlpxeyfjatniau = {pages}
+    elif isinstance(pages, (str, bytes)):
+        raise ValueError('pages must be page numb' + 'ers; use the CLI -p option for ' + 'ranges')
+    else:
+        _dlpxeyfjatniau = {int(page) for page in pages}
+    if not _dlpxeyfjatniau:
+        raise ValueError('at least' + ' on' + 'e page mu' + 'st be selected')
+    _tnnaqceezrapma = sorted((page for page in _dlpxeyfjatniau if page < 1 or page > page_count))
+    if _tnnaqceezrapma:
+        _pghyiyrrqhgdje = ', '.join((str(page) for page in _tnnaqceezrapma))
+        raise ValueError(f'page selection out of range: {_pghyiyrrqhgdje}; PDF has {page_count} page(s)')
+    return _dlpxeyfjatniau
+
+def _rewrite_forms(resources: Any, pdf: PdfWriter, replacements: Sequence[Replacement], preserve_advance: bool, report: ReplacementReport, matched: set[str], visited: set[tuple[Any, ...]], fallback_registry: FallbackFontRegistry, page_number: int) -> None:
+    resources = _deref(resources)
+    xobjects = _deref(resources.get('/XObject', {})) if resources else {}
+    for _, reference in getattr(xobjects, 'items', lambda: [])():
+        form = _deref(reference)
+        if not isinstance(form, StreamObject) or form.get('/Subtype') != '/Form':
+            continue
+        key = _object_key(form)
+        if key in visited:
+            continue
+        visited.add(key)
+        form_resources = _deref(form.get('/Resources')) or resources
+        _rewrite_stream(form, pdf, form_resources, replacements, preserve_advance, report, matched, fallback_registry, page_number)
+        _rewrite_forms(form_resources, pdf, replacements, preserve_advance, report, matched, visited, fallback_registry, page_number)
+
+def replace_pdf_text_detailed(input_pdf: str | os.PathLike[str], output_pdf: str | os.PathLike[str], replacements: Mapping[str, str], *, preserve_advance: bool=True, strict: bool=False, fallback_font: str | os.PathLike[str] | None=None, font_fallback: bool=True, pages: Iterable[int] | int | None=None) -> ReplacementReport:
+    _zsjjgpavxoyeiy = time.perf_counter()
+    _mousvcnaqcrmzc = [Replacement(str(old), str(new)) for old, new in replacements.items() if old]
+    if not _mousvcnaqcrmzc:
+        raise ValueError('At least one non-e' + 'mpty source string is ' + 'req' + 'uired')
+    _tfihdvgamexdzh = Path(input_pdf)
+    _bivdralwetvsjy = Path(output_pdf)
+    if not _tfihdvgamexdzh.is_file():
+        raise PdfFileNotFoundError(f'File not found: {_tfihdvgamexdzh}')
+    _bivdralwetvsjy.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        _vztlargbsowaxh = PdfReader(_tfihdvgamexdzh, strict=False)
+    except DependencyError as _yehswjecufgmvw:
+        raise PdfDependencyError(f"Missing dependency for encrypted PDF: {_yehswjecufgmvw}\nPlease install it, e.g., 'uv pip install cryptography'") from _yehswjecufgmvw
+    except PermissionError as _yehswjecufgmvw:
+        raise PdfPermissionError(f'Permission denied when opening {_tfihdvgamexdzh}. The PDF might be opened by another application.') from _yehswjecufgmvw
+    if _vztlargbsowaxh.is_encrypted:
+        raise PdfReplacementError('Encrypted PDFs are n' + 'ot supported without a password')
+    writer = PdfWriter(clone_from=_vztlargbsowaxh)
+    _jtmgtsgyhkksup = _selected_page_numbers(pages, len(writer.pages))
+    _wgpmzsmmkjcaaw = len(_jtmgtsgyhkksup) != len(writer.pages)
+    _dgfdvonchmlydh = FallbackFontRegistry(writer, explicit_font=fallback_font, enabled=font_fallback)
+    _koppsudxhgbxvc = ReplacementReport(pages=len(writer.pages))
+    _xgcotpgrimnkmc: set[str] = set()
+    _dcnqkkuuzntnmg: set[tuple[Any, ...]] = set()
+    for _fmefrtitqvbple, _lymbmtoympvook in enumerate(writer.pages, start=1):
+        if _fmefrtitqvbple not in _jtmgtsgyhkksup:
+            continue
+        print(_c(f'Processing page {_fmefrtitqvbple}/{_koppsudxhgbxvc.pages}', _BLUE), file=sys.stderr)
+        if _wgpmzsmmkjcaaw:
+            _isolate_selected_page(_lymbmtoympvook, writer)
+        _vciywsdpxmsrtj = _deref(_lymbmtoympvook.get('/Resources', {}))
+        for _uolfadhbwtgzec in _content_streams(_lymbmtoympvook):
+            key = _object_key(_uolfadhbwtgzec)
+            if key in _dcnqkkuuzntnmg:
+                continue
+            _dcnqkkuuzntnmg.add(key)
+            _rewrite_stream(_uolfadhbwtgzec, writer, _vciywsdpxmsrtj, _mousvcnaqcrmzc, preserve_advance, _koppsudxhgbxvc, _xgcotpgrimnkmc, _dgfdvonchmlydh, _fmefrtitqvbple)
+        _rewrite_forms(_vciywsdpxmsrtj, writer, _mousvcnaqcrmzc, preserve_advance, _koppsudxhgbxvc, _xgcotpgrimnkmc, _dcnqkkuuzntnmg, _dgfdvonchmlydh, _fmefrtitqvbple)
+    _dgfdvonchmlydh.finalize()
+    _koppsudxhgbxvc.missing = [rule.old for rule in _mousvcnaqcrmzc if rule.old not in _xgcotpgrimnkmc]
+    _koppsudxhgbxvc.elapsed_seconds = time.perf_counter() - _zsjjgpavxoyeiy
+    if strict and (_koppsudxhgbxvc.missing or _koppsudxhgbxvc.encoding_failures):
+        _xvjnkuuysvwlfj = []
+        if _koppsudxhgbxvc.missing:
+            _xvjnkuuysvwlfj.append(f'not found: {_koppsudxhgbxvc.missing!r}')
+        if _koppsudxhgbxvc.encoding_failures:
+            _xvjnkuuysvwlfj.append(f'encoding failures: {_koppsudxhgbxvc.encoding_failures!r}')
+        raise PdfReplacementError('; '.join(_xvjnkuuysvwlfj))
+    writer.compress_identical_objects(remove_duplicates=True, remove_unreferenced=True)
+    _rpdadeikbebjkm: str | None = None
+    try:
+        try:
+            with tempfile.NamedTemporaryFile(mode='wb', prefix=f'.{_bivdralwetvsjy.name}.', suffix='.tmp', dir=_bivdralwetvsjy.parent, delete=False) as _kegxlnzjvrxfhw:
+                _rpdadeikbebjkm = _kegxlnzjvrxfhw.name
+                writer.write(_kegxlnzjvrxfhw)
+            _ydjqprcywncvtl = PdfReader(_rpdadeikbebjkm, strict=False)
+            if len(_ydjqprcywncvtl.pages) != _koppsudxhgbxvc.pages:
+                raise PdfReplacementError('Output verification found ' + 'a page-count mismatch')
+            os.replace(_rpdadeikbebjkm, _bivdralwetvsjy)
+            _rpdadeikbebjkm = None
+        except PermissionError as _yehswjecufgmvw:
+            raise PdfPermissionError(f'Permission denied when saving to {_bivdralwetvsjy}. The PDF might be opened by another application.') from _yehswjecufgmvw
+    finally:
+        if _rpdadeikbebjkm and os.path.exists(_rpdadeikbebjkm):
+            os.unlink(_rpdadeikbebjkm)
+    _koppsudxhgbxvc.elapsed_seconds = time.perf_counter() - _zsjjgpavxoyeiy
+    return _koppsudxhgbxvc
+
+def replace_pdf_text(input_pdf: str | os.PathLike[str], output_pdf: str | os.PathLike[str], replacements: Mapping[str, str], **kwargs: Any) -> int:
+    return replace_pdf_text_detailed(input_pdf, output_pdf, replacements, **kwargs).replacements