apdf 1.2__tar.gz → 1.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: apdf
-Version: 1.2
+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
@@ -61,7 +61,7 @@ rep = replace_pdf_text_detailed(
     },
 
     # Optional parameters:
-    pages={2, 3, 4},       # Only these pages
+    #pages={2, 3, 4},       # Only these pages
     # pages=2,             # Only page 2
     # pages=range(1, 6),   # Pages 1 through 5
     # pages=None,          # All pages (default)
@@ -81,7 +81,7 @@ print("Encoding failures:", rep.encoding_failures)
 ## Usage As CLI Tool
 
 ```bash
-apdf [-h] [-r OLD=NEW] [-nopa] [-s] [-ff FONT.ttf] [-no-ff] input [output]
+apdf [-h] [-r OLD=NEW] [-nopa] [-s] [-ff FONT.ttf] [-no-ff] [-p PAGELIST] input [output]
 ```
 
 ### Examples

{apdf-1.2 → apdf-1.4}/README.md

@@ -41,7 +41,7 @@ rep = replace_pdf_text_detailed(
     },
 
     # Optional parameters:
-    pages={2, 3, 4},       # Only these pages
+    #pages={2, 3, 4},       # Only these pages
     # pages=2,             # Only page 2
     # pages=range(1, 6),   # Pages 1 through 5
     # pages=None,          # All pages (default)
@@ -61,7 +61,7 @@ print("Encoding failures:", rep.encoding_failures)
 ## Usage As CLI Tool
 
 ```bash
-apdf [-h] [-r OLD=NEW] [-nopa] [-s] [-ff FONT.ttf] [-no-ff] input [output]
+apdf [-h] [-r OLD=NEW] [-nopa] [-s] [-ff FONT.ttf] [-no-ff] [-p PAGELIST] input [output]
 ```
 
 ### Examples

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.4/apdf/codec.py

@@ -0,0 +1,270 @@
+from __future__ import annotations
+import sys
+from io import BytesIO
+from typing import Any, Mapping
+from fontTools.agl import UV2AGL
+from fontTools.pens.boundsPen import BoundsPen
+from fontTools.ttLib import TTFont
+from pypdf._font import Font
+from pypdf.generic import DictionaryObject
+from apdf.exceptions import FontEncodingError
+from apdf.utils import _deref
+
+class FontCodec:
+
+    def __init__(self, resource_name: str, font_object: DictionaryObject):
+        self.resource_name = resource_name
+        self.pdf_font = _deref(font_object)
+        self.font = Font.from_font_resource(self.pdf_font)
+        self._unicode_to_intermediate: dict[str, str] = {}
+        self._intermediate_to_bytes: dict[str, bytes] = {}
+        self._difference_glyphs: dict[int, str] = {}
+        self._embedded_glyphs: set[str] | None = None
+        self._embedded_ttfont: TTFont | None = None
+        self._embedded_font_bytes: bytes | None = None
+        self._embedded_font_stream: Any | None = None
+        self._embedded_ttfont_loaded = False
+        self._embedded_glyph_order: list[str] = []
+        self._drawable_glyphs: dict[int, bool] = {}
+        self._cid_to_gid_bytes: bytes | None = None
+        self._build_inverse_maps()
+        self._load_glyph_inventory()
+
+    @property
+    def description(self) -> str:
+        _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 _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 _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'))
+        if isinstance(encoding, DictionaryObject):
+            code: int | None = None
+            for item in encoding.get('/Differences', []):
+                item = _deref(item)
+                if isinstance(item, int):
+                    code = int(item)
+                elif code is not None:
+                    self._difference_glyphs[code] = str(item).lstrip('/')
+                    code += 1
+        descriptor_owner = self.pdf_font
+        if str(self.pdf_font.get('/Subtype', '')) == '/Type0':
+            descendants = _deref(self.pdf_font.get('/DescendantFonts', []))
+            if descendants:
+                descriptor_owner = _deref(descendants[0])
+                cid_to_gid = _deref(descriptor_owner.get('/CIDToGIDMap'))
+                if hasattr(cid_to_gid, 'get_data'):
+                    try:
+                        self._cid_to_gid_bytes = cid_to_gid.get_data()
+                    except Exception:
+                        self._cid_to_gid_bytes = b''
+        descriptor = _deref(descriptor_owner.get('/FontDescriptor'))
+        charset = descriptor.get('/CharSet') if descriptor else None
+        if charset:
+            self._embedded_glyphs = {name for name in str(charset).split('/') if name}
+        font_file = _deref(descriptor.get('/FontFile2')) if descriptor else None
+        if font_file is not None and hasattr(font_file, 'get_data'):
+            self._embedded_font_stream = font_file
+
+    def _ensure_embedded_ttfont(self) -> None:
+        if self._embedded_ttfont_loaded:
+            return
+        self._embedded_ttfont_loaded = True
+        if self._embedded_font_bytes is None and self._embedded_font_stream is not None:
+            try:
+                self._embedded_font_bytes = self._embedded_font_stream.get_data()
+            except Exception:
+                self._embedded_font_bytes = None
+        if self._embedded_font_bytes is None:
+            return
+        try:
+            self._embedded_ttfont = TTFont(BytesIO(self._embedded_font_bytes), lazy=False, recalcBBoxes=False, recalcTimestamp=False)
+            self._embedded_glyph_order = self._embedded_ttfont.getGlyphOrder()
+        except Exception:
+            self._embedded_ttfont = None
+            self._embedded_glyph_order = []
+
+    def _gid_for_cid(self, cid: int) -> int:
+        if self._cid_to_gid_bytes is None:
+            return cid
+        _jatgoccybumvbw = cid * 2
+        if _jatgoccybumvbw + 2 > len(self._cid_to_gid_bytes):
+            return 0
+        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)
+        if cached is not None:
+            return cached
+        font = self._embedded_ttfont
+        if font is None or gid <= 0 or gid >= len(self._embedded_glyph_order):
+            self._drawable_glyphs[gid] = False
+            return False
+        name = self._embedded_glyph_order[gid]
+        if name == '.notdef':
+            self._drawable_glyphs[gid] = False
+            return False
+        drawable = False
+        try:
+            glyf = font.get('glyf')
+            if glyf is not None:
+                glyph = glyf[name]
+                drawable = bool(glyph.isComposite() or int(getattr(glyph, 'numberOfContours', 0)) > 0)
+            else:
+                glyph_set = font.getGlyphSet()
+                pen = BoundsPen(glyph_set)
+                glyph_set[name].draw(pen)
+                drawable = pen.bounds is not None
+        except Exception:
+            drawable = False
+        self._drawable_glyphs[gid] = drawable
+        return drawable
+
+    def _validate_type0_glyph_outlines(self, raw: bytes) -> None:
+        self._ensure_embedded_ttfont()
+        if self._embedded_ttfont is None:
+            return
+        encoding = self.font.encoding
+        if not isinstance(encoding, str):
+            return
+        try:
+            _ggkrhwxuukljqr = raw.decode(encoding, errors='strict')
+        except (LookupError, UnicodeError):
+            return
+        for _qyrzffrmdzxhez in _ggkrhwxuukljqr:
+            _unjmlnhyycmucn = self.font.character_map.get(_qyrzffrmdzxhez, _qyrzffrmdzxhez)
+            if _unjmlnhyycmucn and all((character.isspace() for character in _unjmlnhyycmucn)):
+                continue
+            _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):
+            _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:
+            _pattpbonwpdlia = bytes((code,)).decode(codec)
+        except (UnicodeDecodeError, LookupError):
+            return None
+        return UV2AGL.get(ord(_pattpbonwpdlia))
+
+    def _validate_embedded_glyphs(self, raw: bytes, visible: str) -> None:
+        _vqsenaebmchtxj = str(self.pdf_font.get('/Subtype', ''))
+        if _vqsenaebmchtxj == '/Type3':
+            encoding = self.font.encoding
+            if isinstance(encoding, dict):
+                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 _vqsenaebmchtxj == '/Type0':
+            self._validate_type0_glyph_outlines(raw)
+        if self._embedded_glyphs is not None:
+            missing: list[str] = []
+            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}')
+        if self.decode(raw) != visible:
+            raise FontEncodingError(f'{self.description} does not round-trip replacement {visible!r}')
+
+    def decode(self, raw: bytes) -> str:
+        encoding = self.font.encoding
+        if isinstance(encoding, str):
+            try:
+                _tpaceezyldticp = raw.decode(encoding, errors='surrogatepass')
+            except (LookupError, UnicodeError):
+                _jhcxvfjfjxrcfa = 'utf-16-be' if len(raw) % 2 == 0 else 'latin-1'
+                _tpaceezyldticp = raw.decode(_jhcxvfjfjxrcfa, errors='replace')
+        else:
+            _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
+        _cforlarevilftd = sorted(mapping, key=len, reverse=True)
+        output: list[str] = []
+        _zzusctkjdsatuj = 0
+        while _zzusctkjdsatuj < len(text):
+            for key in _cforlarevilftd:
+                if key and text.startswith(key, _zzusctkjdsatuj):
+                    output.append(mapping[key])
+                    _zzusctkjdsatuj += len(key)
+                    break
+            else:
+                output.append(text[_zzusctkjdsatuj])
+                _zzusctkjdsatuj += 1
+        return ''.join(output)
+
+    def encode(self, visible: str) -> bytes:
+        _smuyjzjannqguq = self._greedy_map(visible, self._unicode_to_intermediate)
+        encoding = self.font.encoding
+        if isinstance(encoding, str):
+            try:
+                _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 {_smuyjzjannqguq[_vdtdodqdcncmhs]!r} in {visible!r}')
+        _vllohhdgfteusd = bytes(_vgbbptfknztcnt)
+        self._validate_embedded_glyphs(_vllohhdgfteusd, visible)
+        return _vllohhdgfteusd
+
+    def width(self, visible: str) -> float:
+        try:
+            _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
+
+def _font_codecs(resources: Any) -> dict[str, FontCodec]:
+    resources = _deref(resources)
+    fonts = _deref(resources.get('/Font', {})) if resources else {}
+    result: dict[str, FontCodec] = {}
+    for name, font_ref in getattr(fonts, 'items', lambda: [])():
+        resource_name = str(name)
+        try:
+            result[resource_name] = FontCodec(resource_name, _deref(font_ref))
+        except Exception as exc:
+            print(f'Warning: Skipping unreadable font {resource_name}: {exc}', file=sys.stderr)
+    return result

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