Upload 478 files

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+poppler-23.11.0/Library/bin/cairo.dll filter=lfs diff=lfs merge=lfs -text
+poppler-23.11.0/Library/bin/libcrypto-3-x64.dll filter=lfs diff=lfs merge=lfs -text
+poppler-23.11.0/Library/bin/poppler.dll filter=lfs diff=lfs merge=lfs -text
+poppler-23.11.0/Library/lib/poppler.lib filter=lfs diff=lfs merge=lfs -text

poppler-23.11.0/Library/bin/cairo.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0d41677d426dff76abe58600bfac9e7c845f6f0da9042eb7c22b64a3d5e533da
+size 1016320

poppler-23.11.0/Library/bin/libcrypto-3-x64.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2108d58bcd283f875a4f4c9c4d6c25ba2ac7fef1d0a7c22ba957403033f96e03
+size 6194176

poppler-23.11.0/Library/bin/poppler.dll

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2252a2476bf23c24d65fed0fe0d12ee314feb9d935d6379c2838cd3c49b1a89
+size 5005824

poppler-23.11.0/Library/include/poppler/Annot.h

@@ -0,0 +1,1784 @@
+//========================================================================
+//
+// Annot.h
+//
+// Copyright 2000-2003 Glyph & Cog, LLC
+//
+//========================================================================
+
+//========================================================================
+//
+// Modified under the Poppler project - http://poppler.freedesktop.org
+//
+// All changes made under the Poppler project to this file are licensed
+// under GPL version 2 or later
+//
+// Copyright (C) 2006 Scott Turner <[email protected]>
+// Copyright (C) 2007, 2008 Julien Rebetez <[email protected]>
+// Copyright (C) 2007-2011, 2013, 2015, 2018 Carlos Garcia Campos <[email protected]>
+// Copyright (C) 2007, 2008 Iñigo Martínez <[email protected]>
+// Copyright (C) 2008 Michael Vrable <[email protected]>
+// Copyright (C) 2008 Hugo Mercier <[email protected]>
+// Copyright (C) 2008 Pino Toscano <[email protected]>
+// Copyright (C) 2008 Tomas Are Haavet <[email protected]>
+// Copyright (C) 2009-2011, 2013, 2016-2023 Albert Astals Cid <[email protected]>
+// Copyright (C) 2012, 2013 Fabio D'Urso <[email protected]>
+// Copyright (C) 2012, 2015 Tobias Koenig <[email protected]>
+// Copyright (C) 2013 Thomas Freitag <[email protected]>
+// Copyright (C) 2013, 2017, 2023 Adrian Johnson <[email protected]>
+// Copyright (C) 2018 Klarälvdalens Datakonsult AB, a KDAB Group company, <[email protected]>. Work sponsored by the LiMux project of the city of Munich
+// Copyright (C) 2018 Dileep Sankhla <[email protected]>
+// Copyright (C) 2018-2020 Tobias Deiminger <[email protected]>
+// Copyright (C) 2018, 2020, 2022 Oliver Sander <[email protected]>
+// Copyright (C) 2018 Adam Reichold <[email protected]>
+// Copyright (C) 2019 Umang Malik <[email protected]>
+// Copyright (C) 2019 João Netto <[email protected]>
+// Copyright (C) 2020 Nelson Benítez León <[email protected]>
+// Copyright (C) 2020 Klarälvdalens Datakonsult AB, a KDAB Group company, <[email protected]>. Work sponsored by Technische Universität Dresden
+// Copyright (C) 2020 Katarina Behrens <[email protected]>
+// Copyright (C) 2020 Thorsten Behrens <[email protected]>
+// Copyright (C) 2021 Klarälvdalens Datakonsult AB, a KDAB Group company, <[email protected]>.
+// Copyright (C) 2021 Zachary Travis <[email protected]>
+// Copyright (C) 2021 Mahmoud Ahmed Khalil <[email protected]>
+// Copyright (C) 2021 Georgiy Sgibnev <[email protected]>. Work sponsored by lab50.net.
+// Copyright (C) 2022 Martin <[email protected]>
+//
+// To see a description of the changes please see the Changelog file that
+// came with your tarball or type make ChangeLog if you are building from git
+//
+//========================================================================
+
+#ifndef ANNOT_H
+#define ANNOT_H
+
+#include <memory>
+#include <atomic>
+#include <mutex>
+#include <vector>
+
+#include "AnnotStampImageHelper.h"
+#include "Object.h"
+#include "poppler_private_export.h"
+
+class XRef;
+class Gfx;
+class CharCodeToUnicode;
+class GfxFont;
+class GfxResources;
+class Page;
+class PDFDoc;
+class Form;
+class FormWidget;
+class FormField;
+class FormFieldButton;
+class FormFieldText;
+class FormFieldChoice;
+class FormFieldSignature;
+class PDFRectangle;
+class Movie;
+class LinkAction;
+class Sound;
+class FileSpec;
+
+enum AnnotLineEndingStyle
+{
+    annotLineEndingSquare, // Square
+    annotLineEndingCircle, // Circle
+    annotLineEndingDiamond, // Diamond
+    annotLineEndingOpenArrow, // OpenArrow
+    annotLineEndingClosedArrow, // ClosedArrow
+    annotLineEndingNone, // None
+    annotLineEndingButt, // Butt
+    annotLineEndingROpenArrow, // ROpenArrow
+    annotLineEndingRClosedArrow, // RClosedArrow
+    annotLineEndingSlash // Slash
+};
+
+enum AnnotExternalDataType
+{
+    annotExternalDataMarkupUnknown,
+    annotExternalDataMarkup3D // Markup3D
+};
+
+enum class VariableTextQuadding
+{
+    leftJustified,
+    centered,
+    rightJustified
+};
+
+//------------------------------------------------------------------------
+// AnnotCoord
+//------------------------------------------------------------------------
+
+class AnnotCoord
+{
+public:
+    AnnotCoord() : x(0), y(0) { }
+    AnnotCoord(double _x, double _y) : x(_x), y(_y) { }
+
+    double getX() const { return x; }
+    double getY() const { return y; }
+
+protected:
+    double x, y;
+};
+
+//------------------------------------------------------------------------
+// AnnotPath
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotPath
+{
+public:
+    AnnotPath();
+    explicit AnnotPath(Array *array);
+    explicit AnnotPath(std::vector<AnnotCoord> &&coords);
+    ~AnnotPath();
+
+    AnnotPath(const AnnotPath &) = delete;
+    AnnotPath &operator=(const AnnotPath &other) = delete;
+
+    double getX(int coord) const;
+    double getY(int coord) const;
+    AnnotCoord *getCoord(int coord);
+    int getCoordsLength() const { return coords.size(); }
+
+protected:
+    std::vector<AnnotCoord> coords;
+
+    void parsePathArray(Array *array);
+};
+
+//------------------------------------------------------------------------
+// AnnotCalloutLine
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotCalloutLine
+{
+public:
+    AnnotCalloutLine(double x1, double y1, double x2, double y2);
+    virtual ~AnnotCalloutLine();
+
+    AnnotCalloutLine(const AnnotCalloutLine &) = delete;
+    AnnotCalloutLine &operator=(const AnnotCalloutLine &other) = delete;
+
+    double getX1() const { return coord1.getX(); }
+    double getY1() const { return coord1.getY(); }
+    double getX2() const { return coord2.getX(); }
+    double getY2() const { return coord2.getY(); }
+
+protected:
+    AnnotCoord coord1, coord2;
+};
+
+//------------------------------------------------------------------------
+// AnnotCalloutMultiLine
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotCalloutMultiLine : public AnnotCalloutLine
+{
+public:
+    AnnotCalloutMultiLine(double x1, double y1, double x2, double y2, double x3, double y3);
+    ~AnnotCalloutMultiLine() override;
+
+    double getX3() const { return coord3.getX(); }
+    double getY3() const { return coord3.getY(); }
+
+protected:
+    AnnotCoord coord3;
+};
+
+//------------------------------------------------------------------------
+// AnnotBorderEffect
+//------------------------------------------------------------------------
+
+class AnnotBorderEffect
+{
+public:
+    enum AnnotBorderEffectType
+    {
+        borderEffectNoEffect, // S
+        borderEffectCloudy // C
+    };
+
+    explicit AnnotBorderEffect(Dict *dict);
+
+    AnnotBorderEffectType getEffectType() const { return effectType; }
+    double getIntensity() const { return intensity; }
+
+private:
+    AnnotBorderEffectType effectType; // S  (Default S)
+    double intensity; // I  (Default 0)
+};
+
+//------------------------------------------------------------------------
+// AnnotQuadrilateral
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotQuadrilaterals
+{
+public:
+    class POPPLER_PRIVATE_EXPORT AnnotQuadrilateral
+    {
+    public:
+        AnnotQuadrilateral();
+        AnnotQuadrilateral(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4);
+
+        AnnotCoord coord1, coord2, coord3, coord4;
+    };
+
+    AnnotQuadrilaterals(Array *array, PDFRectangle *rect);
+    AnnotQuadrilaterals(std::unique_ptr<AnnotQuadrilateral[]> &&quads, int quadsLength);
+    ~AnnotQuadrilaterals();
+
+    AnnotQuadrilaterals(const AnnotQuadrilaterals &) = delete;
+    AnnotQuadrilaterals &operator=(const AnnotQuadrilaterals &other) = delete;
+
+    double getX1(int quadrilateral);
+    double getY1(int quadrilateral);
+    double getX2(int quadrilateral);
+    double getY2(int quadrilateral);
+    double getX3(int quadrilateral);
+    double getY3(int quadrilateral);
+    double getX4(int quadrilateral);
+    double getY4(int quadrilateral);
+    int getQuadrilateralsLength() const { return quadrilateralsLength; }
+
+protected:
+    std::unique_ptr<AnnotQuadrilateral[]> quadrilaterals;
+    int quadrilateralsLength;
+};
+
+//------------------------------------------------------------------------
+// AnnotBorder
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotBorder
+{
+public:
+    enum AnnotBorderType
+    {
+        typeArray,
+        typeBS
+    };
+
+    enum AnnotBorderStyle
+    {
+        borderSolid, // Solid
+        borderDashed, // Dashed
+        borderBeveled, // Beveled
+        borderInset, // Inset
+        borderUnderlined // Underlined
+    };
+
+    virtual ~AnnotBorder();
+
+    AnnotBorder(const AnnotBorder &) = delete;
+    AnnotBorder &operator=(const AnnotBorder &other) = delete;
+
+    virtual void setWidth(double new_width) { width = new_width; }
+
+    virtual AnnotBorderType getType() const = 0;
+    virtual double getWidth() const { return width; }
+    virtual const std::vector<double> &getDash() const { return dash; }
+    virtual AnnotBorderStyle getStyle() const { return style; }
+
+    virtual Object writeToObject(XRef *xref) const = 0;
+    virtual std::unique_ptr<AnnotBorder> copy() const = 0;
+
+protected:
+    AnnotBorder();
+
+    bool parseDashArray(Object *dashObj);
+
+    AnnotBorderType type;
+    double width;
+    static const int DASH_LIMIT = 10; // implementation note 82 in Appendix H.
+    std::vector<double> dash;
+    AnnotBorderStyle style;
+};
+
+//------------------------------------------------------------------------
+// AnnotBorderArray
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotBorderArray : public AnnotBorder
+{
+public:
+    AnnotBorderArray();
+    explicit AnnotBorderArray(Array *array);
+
+    void setHorizontalCorner(double hc) { horizontalCorner = hc; }
+    void setVerticalCorner(double vc) { verticalCorner = vc; }
+
+    double getHorizontalCorner() const { return horizontalCorner; }
+    double getVerticalCorner() const { return verticalCorner; }
+
+    std::unique_ptr<AnnotBorder> copy() const override;
+
+private:
+    AnnotBorderType getType() const override { return typeArray; }
+    Object writeToObject(XRef *xref) const override;
+
+    double horizontalCorner; // (Default 0)
+    double verticalCorner; // (Default 0)
+    // double width;                  // (Default 1)  (inherited from AnnotBorder)
+};
+
+//------------------------------------------------------------------------
+// AnnotBorderBS
+//------------------------------------------------------------------------
+
+class AnnotBorderBS : public AnnotBorder
+{
+public:
+    AnnotBorderBS();
+    explicit AnnotBorderBS(Dict *dict);
+
+private:
+    AnnotBorderType getType() const override { return typeBS; }
+    Object writeToObject(XRef *xref) const override;
+
+    const char *getStyleName() const;
+
+    std::unique_ptr<AnnotBorder> copy() const override;
+
+    // double width;           // W  (Default 1)   (inherited from AnnotBorder)
+    // AnnotBorderStyle style; // S  (Default S)   (inherited from AnnotBorder)
+    // double *dash;           // D  (Default [3]) (inherited from AnnotBorder)
+};
+
+//------------------------------------------------------------------------
+// AnnotColor
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotColor
+{
+public:
+    enum AnnotColorSpace
+    {
+        colorTransparent = 0,
+        colorGray = 1,
+        colorRGB = 3,
+        colorCMYK = 4
+    };
+
+    AnnotColor();
+    explicit AnnotColor(double gray);
+    AnnotColor(double r, double g, double b);
+    AnnotColor(double c, double m, double y, double k);
+    explicit AnnotColor(Array *array, int adjust = 0);
+
+    void adjustColor(int adjust);
+
+    AnnotColorSpace getSpace() const { return (AnnotColorSpace)length; }
+    const double *getValues() const { return values; }
+
+    Object writeToObject(XRef *xref) const;
+
+private:
+    double values[4];
+    int length;
+};
+
+//------------------------------------------------------------------------
+// DefaultAppearance
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT DefaultAppearance
+{
+public:
+    DefaultAppearance(Object &&fontNameA, double fontPtSizeA, std::unique_ptr<AnnotColor> &&fontColorA);
+    explicit DefaultAppearance(const GooString *da);
+    void setFontName(Object &&fontNameA);
+    const Object &getFontName() const { return fontName; }
+    void setFontPtSize(double fontPtSizeA);
+    double getFontPtSize() const { return fontPtSize; }
+    void setFontColor(std::unique_ptr<AnnotColor> fontColorA);
+    const AnnotColor *getFontColor() const { return fontColor.get(); }
+    std::string toAppearanceString() const;
+
+    DefaultAppearance(const DefaultAppearance &) = delete;
+    DefaultAppearance &operator=(const DefaultAppearance &) = delete;
+
+private:
+    Object fontName;
+    double fontPtSize;
+    std::unique_ptr<AnnotColor> fontColor;
+};
+
+//------------------------------------------------------------------------
+// AnnotIconFit
+//------------------------------------------------------------------------
+
+class AnnotIconFit
+{
+public:
+    enum AnnotIconFitScaleWhen
+    {
+        scaleAlways, // A
+        scaleBigger, // B
+        scaleSmaller, // S
+        scaleNever // N
+    };
+
+    enum AnnotIconFitScale
+    {
+        scaleAnamorphic, // A
+        scaleProportional // P
+    };
+
+    explicit AnnotIconFit(Dict *dict);
+
+    AnnotIconFitScaleWhen getScaleWhen() { return scaleWhen; }
+    AnnotIconFitScale getScale() { return scale; }
+    double getLeft() { return left; }
+    double getBottom() { return bottom; }
+    bool getFullyBounds() { return fullyBounds; }
+
+protected:
+    AnnotIconFitScaleWhen scaleWhen; // SW (Default A)
+    AnnotIconFitScale scale; // S  (Default P)
+    double left; // A  (Default [0.5 0.5]
+    double bottom; // Only if scale is P
+    bool fullyBounds; // FB (Default false)
+};
+
+//------------------------------------------------------------------------
+// AnnotAppearance
+//------------------------------------------------------------------------
+
+class AnnotAppearance
+{
+public:
+    enum AnnotAppearanceType
+    {
+        appearNormal,
+        appearRollover,
+        appearDown
+    };
+
+    AnnotAppearance(PDFDoc *docA, Object *dict);
+    ~AnnotAppearance();
+
+    // State is ignored if no subdictionary is present
+    Object getAppearanceStream(AnnotAppearanceType type, const char *state);
+
+    // Access keys in normal appearance subdictionary (N)
+    std::unique_ptr<GooString> getStateKey(int i);
+    int getNumStates();
+
+    // Removes all associated streams in the xref table. Caller is required to
+    // reset parent annotation's AP and AS after this call.
+    void removeAllStreams();
+
+    // Test if this AnnotAppearance references the specified stream
+    bool referencesStream(Ref refToStream);
+
+private:
+    static bool referencesStream(const Object *stateObj, Ref refToStream);
+    void removeStream(Ref refToStream);
+    void removeStateStreams(const Object *state);
+
+protected:
+    PDFDoc *doc;
+    Object appearDict; // Annotation's AP
+};
+
+//------------------------------------------------------------------------
+// AnnotAppearanceCharacs
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotAppearanceCharacs
+{
+public:
+    enum AnnotAppearanceCharacsTextPos
+    {
+        captionNoIcon, // 0
+        captionNoCaption, // 1
+        captionBelow, // 2
+        captionAbove, // 3
+        captionRight, // 4
+        captionLeft, // 5
+        captionOverlaid // 6
+    };
+
+    explicit AnnotAppearanceCharacs(Dict *dict);
+    ~AnnotAppearanceCharacs();
+
+    AnnotAppearanceCharacs(const AnnotAppearanceCharacs &) = delete;
+    AnnotAppearanceCharacs &operator=(const AnnotAppearanceCharacs &) = delete;
+
+    int getRotation() const { return rotation; }
+    const AnnotColor *getBorderColor() const { return borderColor.get(); }
+    void setBorderColor(std::unique_ptr<AnnotColor> &&color) { borderColor = std::move(color); }
+    const AnnotColor *getBackColor() const { return backColor.get(); }
+    void setBackColor(std::unique_ptr<AnnotColor> &&color) { backColor = std::move(color); }
+    const GooString *getNormalCaption() const { return normalCaption.get(); }
+    const GooString *getRolloverCaption() { return rolloverCaption.get(); }
+    const GooString *getAlternateCaption() { return alternateCaption.get(); }
+    const AnnotIconFit *getIconFit() { return iconFit.get(); }
+    AnnotAppearanceCharacsTextPos getPosition() const { return position; }
+
+    std::unique_ptr<AnnotAppearanceCharacs> copy() const;
+
+protected:
+    int rotation; // R  (Default 0)
+    std::unique_ptr<AnnotColor> borderColor; // BC
+    std::unique_ptr<AnnotColor> backColor; // BG
+    std::unique_ptr<GooString> normalCaption; // CA
+    std::unique_ptr<GooString> rolloverCaption; // RC
+    std::unique_ptr<GooString> alternateCaption; // AC
+    // I
+    // RI
+    // IX
+    std::unique_ptr<AnnotIconFit> iconFit; // IF
+    AnnotAppearanceCharacsTextPos position; // TP (Default 0)
+};
+
+//------------------------------------------------------------------------
+// AnnotAppearanceBBox
+//------------------------------------------------------------------------
+
+class AnnotAppearanceBBox
+{
+public:
+    explicit AnnotAppearanceBBox(PDFRectangle *rect);
+
+    void setBorderWidth(double w) { borderWidth = w; }
+
+    // The following functions operate on coords relative to [origX origY]
+    void extendTo(double x, double y);
+    void getBBoxRect(double bbox[4]) const;
+
+    // Get boundaries in page coordinates
+    double getPageXMin() const;
+    double getPageYMin() const;
+    double getPageXMax() const;
+    double getPageYMax() const;
+
+private:
+    double origX, origY, borderWidth;
+    double minX, minY, maxX, maxY;
+};
+
+//------------------------------------------------------------------------
+// AnnotAppearanceBuilder
+//------------------------------------------------------------------------
+class Matrix;
+
+class AnnotAppearanceBuilder
+{
+public:
+    AnnotAppearanceBuilder();
+    ~AnnotAppearanceBuilder();
+
+    AnnotAppearanceBuilder(const AnnotAppearanceBuilder &) = delete;
+    AnnotAppearanceBuilder &operator=(const AnnotAppearanceBuilder &) = delete;
+
+    void setDrawColor(const AnnotColor *color, bool fill);
+    void setLineStyleForBorder(const AnnotBorder *border);
+    void setTextFont(const Object &fontName, double fontSize);
+    void drawCircle(double cx, double cy, double r, bool fill);
+    void drawEllipse(double cx, double cy, double rx, double ry, bool fill, bool stroke);
+    void drawCircleTopLeft(double cx, double cy, double r);
+    void drawCircleBottomRight(double cx, double cy, double r);
+    void drawLineEnding(AnnotLineEndingStyle endingStyle, double x, double y, double size, bool fill, const Matrix &m);
+    void drawLineEndSquare(double x, double y, double size, bool fill, const Matrix &m);
+    void drawLineEndCircle(double x, double y, double size, bool fill, const Matrix &m);
+    void drawLineEndDiamond(double x, double y, double size, bool fill, const Matrix &m);
+    void drawLineEndArrow(double x, double y, double size, int orientation, bool isOpen, bool fill, const Matrix &m);
+    void drawLineEndSlash(double x, double y, double size, const Matrix &m);
+    void drawFieldBorder(const FormField *field, const AnnotBorder *border, const AnnotAppearanceCharacs *appearCharacs, const PDFRectangle *rect);
+    bool drawFormField(const FormField *field, const Form *form, const GfxResources *resources, const GooString *da, const AnnotBorder *border, const AnnotAppearanceCharacs *appearCharacs, const PDFRectangle *rect,
+                       const GooString *appearState, XRef *xref, Dict *resourcesDict);
+    static double lineEndingXShorten(AnnotLineEndingStyle endingStyle, double size);
+    static double lineEndingXExtendBBox(AnnotLineEndingStyle endingStyle, double size);
+    void writeString(const std::string &str);
+
+    void append(const char *text);
+    void appendf(const char *fmt, ...) GOOSTRING_FORMAT;
+
+    const GooString *buffer() const;
+
+private:
+    enum DrawTextFlags
+    {
+        NoDrawTextFlags = 0,
+        MultilineDrawTextFlag = 1,
+        EmitMarkedContentDrawTextFlag = 2,
+        ForceZapfDingbatsDrawTextFlag = 4,
+        TurnTextToStarsDrawTextFlag = 8
+    };
+
+    bool drawListBox(const FormFieldChoice *fieldChoice, const AnnotBorder *border, const PDFRectangle *rect, const GooString *da, const GfxResources *resources, VariableTextQuadding quadding, XRef *xref, Dict *resourcesDict);
+    bool drawFormFieldButton(const FormFieldButton *field, const Form *form, const GfxResources *resources, const GooString *da, const AnnotBorder *border, const AnnotAppearanceCharacs *appearCharacs, const PDFRectangle *rect,
+                             const GooString *appearState, XRef *xref, Dict *resourcesDict);
+    bool drawFormFieldText(const FormFieldText *fieldText, const Form *form, const GfxResources *resources, const GooString *da, const AnnotBorder *border, const AnnotAppearanceCharacs *appearCharacs, const PDFRectangle *rect, XRef *xref,
+                           Dict *resourcesDict);
+    bool drawFormFieldChoice(const FormFieldChoice *fieldChoice, const Form *form, const GfxResources *resources, const GooString *da, const AnnotBorder *border, const AnnotAppearanceCharacs *appearCharacs, const PDFRectangle *rect,
+                             XRef *xref, Dict *resourcesDict);
+    bool drawSignatureFieldText(const FormFieldSignature *field, const Form *form, const GfxResources *resources, const GooString *da, const AnnotBorder *border, const AnnotAppearanceCharacs *appearCharacs, const PDFRectangle *rect,
+                                XRef *xref, Dict *resourcesDict);
+    void drawSignatureFieldText(const GooString &text, const Form *form, const DefaultAppearance &da, const AnnotBorder *border, const PDFRectangle *rect, XRef *xref, Dict *resourcesDict, double leftMargin, bool centerVertically,
+                                bool centerHorizontally);
+    bool drawText(const GooString *text, const Form *form, const GooString *da, const GfxResources *resources, const AnnotBorder *border, const AnnotAppearanceCharacs *appearCharacs, const PDFRectangle *rect,
+                  const VariableTextQuadding quadding, XRef *xref, Dict *resourcesDict, const int flags = NoDrawTextFlags, const int nCombs = 0);
+    void drawArrowPath(double x, double y, const Matrix &m, int orientation = 1);
+
+    GooString *appearBuf;
+};
+
+//------------------------------------------------------------------------
+// Annot
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT Annot
+{
+    friend class Annots;
+    friend class Page;
+
+public:
+    enum AnnotFlag
+    {
+        flagUnknown = 0x0000,
+        flagInvisible = 0x0001,
+        flagHidden = 0x0002,
+        flagPrint = 0x0004,
+        flagNoZoom = 0x0008,
+        flagNoRotate = 0x0010,
+        flagNoView = 0x0020,
+        flagReadOnly = 0x0040,
+        flagLocked = 0x0080,
+        flagToggleNoView = 0x0100,
+        flagLockedContents = 0x0200
+    };
+
+    enum AnnotSubtype
+    {
+        typeUnknown, //                 0
+        typeText, // Text            1
+        typeLink, // Link            2
+        typeFreeText, // FreeText        3
+        typeLine, // Line            4
+        typeSquare, // Square          5
+        typeCircle, // Circle          6
+        typePolygon, // Polygon         7
+        typePolyLine, // PolyLine        8
+        typeHighlight, // Highlight       9
+        typeUnderline, // Underline      10
+        typeSquiggly, // Squiggly       11
+        typeStrikeOut, // StrikeOut      12
+        typeStamp, // Stamp          13
+        typeCaret, // Caret          14
+        typeInk, // Ink            15
+        typePopup, // Popup          16
+        typeFileAttachment, // FileAttachment 17
+        typeSound, // Sound          18
+        typeMovie, // Movie          19
+        typeWidget, // Widget         20
+        typeScreen, // Screen         21
+        typePrinterMark, // PrinterMark    22
+        typeTrapNet, // TrapNet        23
+        typeWatermark, // Watermark      24
+        type3D, // 3D             25
+        typeRichMedia // RichMedia      26
+    };
+
+    /**
+     * Describes the additional actions of a screen or widget annotation.
+     */
+    enum AdditionalActionsType
+    {
+        actionCursorEntering, ///< Performed when the cursor enters the annotation's active area
+        actionCursorLeaving, ///< Performed when the cursor exists the annotation's active area
+        actionMousePressed, ///< Performed when the mouse button is pressed inside the annotation's active area
+        actionMouseReleased, ///< Performed when the mouse button is released inside the annotation's active area
+        actionFocusIn, ///< Performed when the annotation receives the input focus
+        actionFocusOut, ///< Performed when the annotation loses the input focus
+        actionPageOpening, ///< Performed when the page containing the annotation is opened
+        actionPageClosing, ///< Performed when the page containing the annotation is closed
+        actionPageVisible, ///< Performed when the page containing the annotation becomes visible
+        actionPageInvisible ///< Performed when the page containing the annotation becomes invisible
+    };
+
+    enum FormAdditionalActionsType
+    {
+        actionFieldModified, ///< Performed when the when the user modifies the field
+        actionFormatField, ///< Performed before the field is formatted to display its value
+        actionValidateField, ///< Performed when the field value changes
+        actionCalculateField, ///< Performed when the field needs to be recalculated
+    };
+
+    Annot(PDFDoc *docA, PDFRectangle *rectA);
+    Annot(PDFDoc *docA, Object &&dictObject);
+    Annot(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    bool isOk() { return ok; }
+
+    void incRefCnt();
+    void decRefCnt();
+
+    virtual void draw(Gfx *gfx, bool printing);
+    // Get the resource dict of the appearance stream
+    virtual Object getAppearanceResDict();
+
+    bool match(const Ref *refA) const { return ref == *refA; }
+
+    double getXMin();
+    double getYMin();
+    double getXMax();
+    double getYMax();
+
+    void setRect(const PDFRectangle *rect);
+    void setRect(double x1, double y1, double x2, double y2);
+
+    // Sets the annot contents to new_content
+    // new_content should never be NULL
+    virtual void setContents(std::unique_ptr<GooString> &&new_content);
+    void setName(GooString *new_name);
+    void setModified(GooString *new_modified);
+    void setFlags(unsigned int new_flags);
+
+    void setBorder(std::unique_ptr<AnnotBorder> &&new_border);
+    void setColor(std::unique_ptr<AnnotColor> &&new_color);
+
+    void setAppearanceState(const char *state);
+
+    // getters
+    PDFDoc *getDoc() const { return doc; }
+    bool getHasRef() const { return hasRef; }
+    Ref getRef() const { return ref; }
+    const Object &getAnnotObj() const { return annotObj; }
+    AnnotSubtype getType() const { return type; }
+    const PDFRectangle &getRect() const { return *rect; }
+    void getRect(double *x1, double *y1, double *x2, double *y2) const;
+    const GooString *getContents() const { return contents.get(); }
+    int getPageNum() const { return page; }
+    const GooString *getName() const { return name.get(); }
+    const GooString *getModified() const { return modified.get(); }
+    unsigned int getFlags() const { return flags; }
+    Object getAppearance() const;
+    void setNewAppearance(Object &&newAppearance);
+    AnnotAppearance *getAppearStreams() const { return appearStreams.get(); }
+    const GooString *getAppearState() const { return appearState.get(); }
+    AnnotBorder *getBorder() const { return border.get(); }
+    AnnotColor *getColor() const { return color.get(); }
+    int getTreeKey() const { return treeKey; }
+
+    int getId() { return ref.num; }
+
+    // Check if point is inside the annot rectangle.
+    bool inRect(double x, double y) const;
+
+    // If newFontNeeded is not null, it will contain whether the given font has glyphs to represent the needed text
+    static void layoutText(const GooString *text, GooString *outBuf, int *i, const GfxFont &font, double *width, double widthLimit, int *charCount, bool noReencode, bool *newFontNeeded = nullptr);
+
+private:
+    void readArrayNum(Object *pdfArray, int key, double *value);
+    // write vStr[i:j[ in appearBuf
+
+    void initialize(PDFDoc *docA, Dict *dict);
+    void setPage(int pageIndex, bool updateP); // Called by Page::addAnnot and Annots ctor
+
+protected:
+    virtual ~Annot();
+    virtual void removeReferencedObjects(); // Called by Page::removeAnnot
+    Object createForm(const GooString *appearBuf, const double *bbox, bool transparencyGroup, Dict *resDict);
+    Object createForm(const GooString *appearBuf, const double *bbox, bool transparencyGroup, Object &&resDictObject); // overload to support incRef/decRef
+    Dict *createResourcesDict(const char *formName, Object &&formStream, const char *stateName, double opacity, const char *blendMode);
+    bool isVisible(bool printing);
+    int getRotation() const;
+
+    // Updates the field key of the annotation dictionary
+    // and sets M to the current time
+    void update(const char *key, Object &&value);
+
+    // Delete appearance streams and reset appearance state
+    virtual void invalidateAppearance();
+
+    Object annotObj;
+
+    std::atomic_int refCnt;
+
+    // required data
+    AnnotSubtype type; // Annotation type
+    std::unique_ptr<PDFRectangle> rect; // Rect
+
+    // optional data
+    std::unique_ptr<GooString> contents; // Contents
+    std::unique_ptr<GooString> name; // NM
+    std::unique_ptr<GooString> modified; // M
+    int page; // P
+    unsigned int flags; // F (must be a 32 bit unsigned int)
+    std::unique_ptr<AnnotAppearance> appearStreams; // AP
+    Object appearance; // a reference to the Form XObject stream
+                       //   for the normal appearance
+    std::unique_ptr<AnnotAppearanceBBox> appearBBox; // BBox of generated appearance
+    std::unique_ptr<GooString> appearState; // AS
+    int treeKey; // Struct Parent;
+    Object oc; // OC
+
+    PDFDoc *doc;
+    Ref ref; // object ref identifying this annotation
+    std::unique_ptr<AnnotBorder> border; // Border, BS
+    std::unique_ptr<AnnotColor> color; // C
+    bool ok;
+
+    bool hasRef;
+    mutable std::recursive_mutex mutex;
+
+    bool hasBeenUpdated = false;
+};
+
+//------------------------------------------------------------------------
+// AnnotPopup
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotPopup : public Annot
+{
+public:
+    AnnotPopup(PDFDoc *docA, PDFRectangle *rect);
+    AnnotPopup(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~AnnotPopup() override;
+
+    bool hasParent() const { return parentRef != Ref::INVALID(); }
+    void setParent(Annot *parentA);
+    bool getOpen() const { return open; }
+    void setOpen(bool openA);
+
+protected:
+    void initialize(PDFDoc *docA, Dict *dict);
+
+    Ref parentRef; // Parent
+    bool open; // Open
+};
+
+//------------------------------------------------------------------------
+// AnnotMarkup
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotMarkup : public Annot
+{
+public:
+    enum AnnotMarkupReplyType
+    {
+        replyTypeR, // R
+        replyTypeGroup // Group
+    };
+
+    AnnotMarkup(PDFDoc *docA, PDFRectangle *rect);
+    AnnotMarkup(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~AnnotMarkup() override;
+
+    // getters
+    const GooString *getLabel() const { return label.get(); }
+    AnnotPopup *getPopup() const { return popup.get(); }
+    double getOpacity() const { return opacity; }
+    // getRC
+    const GooString *getDate() const { return date.get(); }
+    bool isInReplyTo() const { return inReplyTo != Ref::INVALID(); }
+    int getInReplyToID() const { return inReplyTo.num; }
+    const GooString *getSubject() const { return subject.get(); }
+    AnnotMarkupReplyType getReplyTo() const { return replyTo; }
+    AnnotExternalDataType getExData() const { return exData; }
+
+    // The annotation takes the ownership of new_popup
+    void setPopup(std::unique_ptr<AnnotPopup> &&new_popup);
+    void setLabel(std::unique_ptr<GooString> &&new_label);
+    void setOpacity(double opacityA);
+    void setDate(GooString *new_date);
+
+protected:
+    void removeReferencedObjects() override;
+
+    std::unique_ptr<GooString> label; // T            (Default author)
+    std::unique_ptr<AnnotPopup> popup; // Popup
+    double opacity; // CA           (Default 1.0)
+    // RC
+    std::unique_ptr<GooString> date; // CreationDate
+    Ref inReplyTo; // IRT
+    std::unique_ptr<GooString> subject; // Subj
+    AnnotMarkupReplyType replyTo; // RT           (Default R)
+    // this object is overridden by the custom intent fields defined in some
+    // annotation types.
+    // GooString *intent;                // IT
+    AnnotExternalDataType exData; // ExData
+
+private:
+    void initialize(PDFDoc *docA, Dict *dict);
+};
+
+//------------------------------------------------------------------------
+// AnnotText
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotText : public AnnotMarkup
+{
+public:
+    enum AnnotTextState
+    {
+        stateUnknown,
+        // Marked state model
+        stateMarked, // Marked
+        stateUnmarked, // Unmarked
+        // Review state model
+        stateAccepted, // Accepted
+        stateRejected, // Rejected
+        stateCancelled, // Cancelled
+        stateCompleted, // Completed
+        stateNone // None
+    };
+
+    AnnotText(PDFDoc *docA, PDFRectangle *rect);
+    AnnotText(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~AnnotText() override;
+
+    void draw(Gfx *gfx, bool printing) override;
+
+    // getters
+    bool getOpen() const { return open; }
+    const GooString *getIcon() const { return icon.get(); }
+    AnnotTextState getState() const { return state; }
+
+    void setOpen(bool openA);
+    void setIcon(GooString *new_icon);
+
+private:
+    void initialize(PDFDoc *docA, Dict *dict);
+
+    bool open; // Open       (Default false)
+    std::unique_ptr<GooString> icon; // Name       (Default Note)
+    AnnotTextState state; // State      (Default Umarked if
+                          //             StateModel Marked
+                          //             None if StareModel Review)
+};
+
+//------------------------------------------------------------------------
+// AnnotMovie
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotMovie : public Annot
+{
+public:
+    AnnotMovie(PDFDoc *docA, PDFRectangle *rect, Movie *movieA);
+    AnnotMovie(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~AnnotMovie() override;
+
+    void draw(Gfx *gfx, bool printing) override;
+
+    const GooString *getTitle() const { return title.get(); }
+    Movie *getMovie() { return movie.get(); }
+
+private:
+    void initialize(PDFDoc *docA, Dict *dict);
+
+    std::unique_ptr<GooString> title; // T
+    std::unique_ptr<Movie> movie; // Movie + A
+};
+
+//------------------------------------------------------------------------
+// AnnotScreen
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotScreen : public Annot
+{
+public:
+    AnnotScreen(PDFDoc *docA, PDFRectangle *rect);
+    AnnotScreen(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~AnnotScreen() override;
+
+    const GooString *getTitle() const { return title.get(); }
+
+    AnnotAppearanceCharacs *getAppearCharacs() { return appearCharacs.get(); }
+    LinkAction *getAction() { return action.get(); } // The caller should not delete the result
+    std::unique_ptr<LinkAction> getAdditionalAction(AdditionalActionsType type);
+
+private:
+    void initialize(PDFDoc *docA, Dict *dict);
+
+    std::unique_ptr<GooString> title; // T
+
+    std::unique_ptr<AnnotAppearanceCharacs> appearCharacs; // MK
+
+    std::unique_ptr<LinkAction> action; // A
+    Object additionalActions; // AA
+};
+
+//------------------------------------------------------------------------
+// AnnotLink
+//------------------------------------------------------------------------
+
+class AnnotLink : public Annot
+{
+public:
+    enum AnnotLinkEffect
+    {
+        effectNone, // N
+        effectInvert, // I
+        effectOutline, // O
+        effectPush // P
+    };
+
+    AnnotLink(PDFDoc *docA, PDFRectangle *rect);
+    AnnotLink(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~AnnotLink() override;
+
+    void draw(Gfx *gfx, bool printing) override;
+
+    // getters
+    LinkAction *getAction() const { return action.get(); }
+    AnnotLinkEffect getLinkEffect() const { return linkEffect; }
+    AnnotQuadrilaterals *getQuadrilaterals() const { return quadrilaterals.get(); }
+
+protected:
+    void initialize(PDFDoc *docA, Dict *dict);
+
+    std::unique_ptr<LinkAction> action; // A, Dest
+    AnnotLinkEffect linkEffect; // H          (Default I)
+    // Dict *uriAction;                                   // PA
+
+    std::unique_ptr<AnnotQuadrilaterals> quadrilaterals; // QuadPoints
+};
+
+//------------------------------------------------------------------------
+// AnnotFreeText
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotFreeText : public AnnotMarkup
+{
+public:
+    enum AnnotFreeTextIntent
+    {
+        intentFreeText, // FreeText
+        intentFreeTextCallout, // FreeTextCallout
+        intentFreeTextTypeWriter // FreeTextTypeWriter
+    };
+
+    static const double undefinedFontPtSize;
+
+    AnnotFreeText(PDFDoc *docA, PDFRectangle *rect);
+    AnnotFreeText(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~AnnotFreeText() override;
+
+    void draw(Gfx *gfx, bool printing) override;
+    Object getAppearanceResDict() override;
+    void setContents(std::unique_ptr<GooString> &&new_content) override;
+
+    void setDefaultAppearance(const DefaultAppearance &da);
+    void setQuadding(VariableTextQuadding new_quadding);
+    void setStyleString(GooString *new_string);
+    void setCalloutLine(AnnotCalloutLine *line);
+    void setIntent(AnnotFreeTextIntent new_intent);
+
+    // getters
+    std::unique_ptr<DefaultAppearance> getDefaultAppearance() const;
+    VariableTextQuadding getQuadding() const { return quadding; }
+    // return rc
+    const GooString *getStyleString() const { return styleString.get(); }
+    AnnotCalloutLine *getCalloutLine() const { return calloutLine.get(); }
+    AnnotFreeTextIntent getIntent() const { return intent; }
+    AnnotBorderEffect *getBorderEffect() const { return borderEffect.get(); }
+    PDFRectangle *getRectangle() const { return rectangle.get(); }
+    AnnotLineEndingStyle getEndStyle() const { return endStyle; }
+
+protected:
+    void initialize(PDFDoc *docA, Dict *dict);
+    void generateFreeTextAppearance();
+
+    // required
+    std::unique_ptr<GooString> appearanceString; // DA
+
+    // optional
+    VariableTextQuadding quadding; // Q  (Default 0)
+    // RC
+    std::unique_ptr<GooString> styleString; // DS
+    std::unique_ptr<AnnotCalloutLine> calloutLine; // CL
+    AnnotFreeTextIntent intent; // IT
+    std::unique_ptr<AnnotBorderEffect> borderEffect; // BE
+    std::unique_ptr<PDFRectangle> rectangle; // RD
+    // inherited  from Annot
+    // AnnotBorderBS border;                          // BS
+    AnnotLineEndingStyle endStyle; // LE (Default None)
+};
+
+//------------------------------------------------------------------------
+// AnnotLine
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotLine : public AnnotMarkup
+{
+public:
+    enum AnnotLineIntent
+    {
+        intentLineArrow, // LineArrow
+        intentLineDimension // LineDimension
+    };
+
+    enum AnnotLineCaptionPos
+    {
+        captionPosInline, // Inline
+        captionPosTop // Top
+    };
+
+    AnnotLine(PDFDoc *docA, PDFRectangle *rect);
+    AnnotLine(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~AnnotLine() override;
+
+    void draw(Gfx *gfx, bool printing) override;
+    Object getAppearanceResDict() override;
+    void setContents(std::unique_ptr<GooString> &&new_content) override;
+
+    void setVertices(double x1, double y1, double x2, double y2);
+    void setStartEndStyle(AnnotLineEndingStyle start, AnnotLineEndingStyle end);
+    void setInteriorColor(std::unique_ptr<AnnotColor> &&new_color);
+    void setLeaderLineLength(double len);
+    void setLeaderLineExtension(double len);
+    void setCaption(bool new_cap);
+    void setIntent(AnnotLineIntent new_intent);
+
+    // getters
+    AnnotLineEndingStyle getStartStyle() const { return startStyle; }
+    AnnotLineEndingStyle getEndStyle() const { return endStyle; }
+    AnnotColor *getInteriorColor() const { return interiorColor.get(); }
+    double getLeaderLineLength() const { return leaderLineLength; }
+    double getLeaderLineExtension() const { return leaderLineExtension; }
+    bool getCaption() const { return caption; }
+    AnnotLineIntent getIntent() const { return intent; }
+    double getLeaderLineOffset() const { return leaderLineOffset; }
+    AnnotLineCaptionPos getCaptionPos() const { return captionPos; }
+    Dict *getMeasure() const { return measure; }
+    double getCaptionTextHorizontal() const { return captionTextHorizontal; }
+    double getCaptionTextVertical() const { return captionTextVertical; }
+    double getX1() const { return coord1->getX(); }
+    double getY1() const { return coord1->getY(); }
+    double getX2() const { return coord2->getX(); }
+    double getY2() const { return coord2->getY(); }
+
+protected:
+    void initialize(PDFDoc *docA, Dict *dict);
+    void generateLineAppearance();
+
+    // required
+    std::unique_ptr<AnnotCoord> coord1;
+    std::unique_ptr<AnnotCoord> coord2;
+
+    // optional
+    // inherited  from Annot
+    // AnnotBorderBS border;                   // BS
+    AnnotLineEndingStyle startStyle; // LE       (Default [/None /None])
+    AnnotLineEndingStyle endStyle; //
+    std::unique_ptr<AnnotColor> interiorColor; // IC
+    double leaderLineLength; // LL       (Default 0)
+    double leaderLineExtension; // LLE      (Default 0)
+    bool caption; // Cap      (Default false)
+    AnnotLineIntent intent; // IT
+    double leaderLineOffset; // LLO
+    AnnotLineCaptionPos captionPos; // CP       (Default Inline)
+    Dict *measure; // Measure
+    double captionTextHorizontal; // CO       (Default [0, 0])
+    double captionTextVertical; //
+};
+
+//------------------------------------------------------------------------
+// AnnotTextMarkup
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotTextMarkup : public AnnotMarkup
+{
+public:
+    AnnotTextMarkup(PDFDoc *docA, PDFRectangle *rect, AnnotSubtype subType);
+    AnnotTextMarkup(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~AnnotTextMarkup() override;
+
+    void draw(Gfx *gfx, bool printing) override;
+
+    // typeHighlight, typeUnderline, typeSquiggly or typeStrikeOut
+    void setType(AnnotSubtype new_type);
+
+    void setQuadrilaterals(AnnotQuadrilaterals *quadPoints);
+
+    AnnotQuadrilaterals *getQuadrilaterals() const { return quadrilaterals.get(); }
+
+protected:
+    void initialize(PDFDoc *docA, Dict *dict);
+
+    std::unique_ptr<AnnotQuadrilaterals> quadrilaterals; // QuadPoints
+
+private:
+    bool shouldCreateApperance(Gfx *gfx) const;
+};
+
+//------------------------------------------------------------------------
+// AnnotStamp
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotStamp : public AnnotMarkup
+{
+public:
+    AnnotStamp(PDFDoc *docA, PDFRectangle *rect);
+    AnnotStamp(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~AnnotStamp() override;
+
+    void draw(Gfx *gfx, bool printing) override;
+
+    void setIcon(GooString *new_icon);
+
+    void setCustomImage(AnnotStampImageHelper *stampImageHelperA);
+
+    void clearCustomImage();
+
+    // getters
+    const GooString *getIcon() const { return icon.get(); }
+
+private:
+    void initialize(PDFDoc *docA, Dict *dict);
+    void generateStampDefaultAppearance();
+    void generateStampCustomAppearance();
+
+    std::unique_ptr<GooString> icon; // Name       (Default Draft)
+    AnnotStampImageHelper *stampImageHelper;
+    Ref updatedAppearanceStream;
+};
+
+//------------------------------------------------------------------------
+// AnnotGeometry
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotGeometry : public AnnotMarkup
+{
+public:
+    AnnotGeometry(PDFDoc *docA, PDFRectangle *rect, AnnotSubtype subType);
+    AnnotGeometry(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~AnnotGeometry() override;
+
+    void draw(Gfx *gfx, bool printing) override;
+
+    void setType(AnnotSubtype new_type); // typeSquare or typeCircle
+    void setInteriorColor(std::unique_ptr<AnnotColor> &&new_color);
+
+    // getters
+    AnnotColor *getInteriorColor() const { return interiorColor.get(); }
+    AnnotBorderEffect *getBorderEffect() const { return borderEffect.get(); }
+    PDFRectangle *getGeometryRect() const { return geometryRect.get(); }
+
+private:
+    void initialize(PDFDoc *docA, Dict *dict);
+
+    std::unique_ptr<AnnotColor> interiorColor; // IC
+    std::unique_ptr<AnnotBorderEffect> borderEffect; // BE
+    std::unique_ptr<PDFRectangle> geometryRect; // RD (combined with Rect)
+};
+
+//------------------------------------------------------------------------
+// AnnotPolygon
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotPolygon : public AnnotMarkup
+{
+public:
+    enum AnnotPolygonIntent
+    {
+        polygonCloud, // PolygonCloud
+        polylineDimension, // PolyLineDimension
+        polygonDimension // PolygonDimension
+    };
+
+    AnnotPolygon(PDFDoc *docA, PDFRectangle *rect, AnnotSubtype subType);
+    AnnotPolygon(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~AnnotPolygon() override;
+
+    void draw(Gfx *gfx, bool printing) override;
+    void generatePolyLineAppearance(AnnotAppearanceBuilder *appearBuilder);
+    void setType(AnnotSubtype new_type); // typePolygon or typePolyLine
+    void setVertices(AnnotPath *path);
+    void setStartEndStyle(AnnotLineEndingStyle start, AnnotLineEndingStyle end);
+    void setInteriorColor(std::unique_ptr<AnnotColor> &&new_color);
+    void setIntent(AnnotPolygonIntent new_intent);
+
+    // getters
+    AnnotPath *getVertices() const { return vertices.get(); }
+    AnnotLineEndingStyle getStartStyle() const { return startStyle; }
+    AnnotLineEndingStyle getEndStyle() const { return endStyle; }
+    AnnotColor *getInteriorColor() const { return interiorColor.get(); }
+    AnnotBorderEffect *getBorderEffect() const { return borderEffect.get(); }
+    AnnotPolygonIntent getIntent() const { return intent; }
+
+private:
+    void initialize(PDFDoc *docA, Dict *dict);
+
+    // required
+    std::unique_ptr<AnnotPath> vertices; // Vertices
+
+    // optional
+    AnnotLineEndingStyle startStyle; // LE       (Default [/None /None])
+    AnnotLineEndingStyle endStyle; //
+    // inherited  from Annot
+    // AnnotBorderBS border;                          // BS
+    std::unique_ptr<AnnotColor> interiorColor; // IC
+    std::unique_ptr<AnnotBorderEffect> borderEffect; // BE
+    AnnotPolygonIntent intent; // IT
+    // Measure
+};
+
+//------------------------------------------------------------------------
+// AnnotCaret
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotCaret : public AnnotMarkup
+{
+public:
+    enum AnnotCaretSymbol
+    {
+        symbolNone, // None
+        symbolP // P
+    };
+
+    AnnotCaret(PDFDoc *docA, PDFRectangle *rect);
+    AnnotCaret(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~AnnotCaret() override;
+
+    void setSymbol(AnnotCaretSymbol new_symbol);
+
+    // getters
+    AnnotCaretSymbol getSymbol() const { return symbol; }
+    PDFRectangle *getCaretRect() const { return caretRect.get(); }
+
+private:
+    void initialize(PDFDoc *docA, Dict *dict);
+
+    AnnotCaretSymbol symbol; // Sy         (Default None)
+    std::unique_ptr<PDFRectangle> caretRect; // RD (combined with Rect)
+};
+
+//------------------------------------------------------------------------
+// AnnotInk
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotInk : public AnnotMarkup
+{
+public:
+    AnnotInk(PDFDoc *docA, PDFRectangle *rect);
+    AnnotInk(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~AnnotInk() override;
+
+    void draw(Gfx *gfx, bool printing) override;
+
+    void setInkList(AnnotPath **paths, int n_paths);
+
+    // getters
+    AnnotPath **getInkList() const { return inkList; }
+    int getInkListLength() const { return inkListLength; }
+
+private:
+    void initialize(PDFDoc *docA, Dict *dict);
+    void writeInkList(AnnotPath **paths, int n_paths, Array *dest_array);
+    void parseInkList(Array *src_array);
+    void freeInkList();
+
+    // required
+    AnnotPath **inkList; // InkList
+    int inkListLength;
+
+    // optional
+    // inherited from Annot
+    // AnnotBorderBS border;  // BS
+};
+
+//------------------------------------------------------------------------
+// AnnotFileAttachment
+//------------------------------------------------------------------------
+
+class AnnotFileAttachment : public AnnotMarkup
+{
+public:
+    AnnotFileAttachment(PDFDoc *docA, PDFRectangle *rect, GooString *filename);
+    AnnotFileAttachment(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~AnnotFileAttachment() override;
+
+    void draw(Gfx *gfx, bool printing) override;
+
+    // getters
+    Object *getFile() { return &file; }
+    const GooString *getName() const { return name.get(); }
+
+private:
+    void initialize(PDFDoc *docA, Dict *dict);
+
+    // required
+    Object file; // FS
+
+    // optional
+    std::unique_ptr<GooString> name; // Name
+};
+
+//------------------------------------------------------------------------
+// AnnotSound
+//------------------------------------------------------------------------
+
+class AnnotSound : public AnnotMarkup
+{
+public:
+    AnnotSound(PDFDoc *docA, PDFRectangle *rect, Sound *soundA);
+    AnnotSound(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~AnnotSound() override;
+
+    void draw(Gfx *gfx, bool printing) override;
+
+    // getters
+    Sound *getSound() { return sound.get(); }
+    const GooString *getName() const { return name.get(); }
+
+private:
+    void initialize(PDFDoc *docA, Dict *dict);
+
+    // required
+    std::unique_ptr<Sound> sound; // Sound
+
+    // optional
+    std::unique_ptr<GooString> name; // Name
+};
+
+//------------------------------------------------------------------------
+// AnnotWidget
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotWidget : public Annot
+{
+public:
+    enum AnnotWidgetHighlightMode
+    {
+        highlightModeNone, // N
+        highlightModeInvert, // I
+        highlightModeOutline, // O
+        highlightModePush // P,T
+    };
+
+    AnnotWidget(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    AnnotWidget(PDFDoc *docA, Object *dictObject, Object *obj, FormField *fieldA);
+    ~AnnotWidget() override;
+
+    void draw(Gfx *gfx, bool printing) override;
+    void invalidateAppearance() override;
+
+    void generateFieldAppearance();
+    void updateAppearanceStream();
+
+    AnnotWidgetHighlightMode getMode() { return mode; }
+    AnnotAppearanceCharacs *getAppearCharacs() { return appearCharacs.get(); }
+    void setAppearCharacs(std::unique_ptr<AnnotAppearanceCharacs> &&appearCharacsA) { appearCharacs = std::move(appearCharacsA); }
+    LinkAction *getAction() { return action.get(); } // The caller should not delete the result
+    std::unique_ptr<LinkAction> getAdditionalAction(AdditionalActionsType type);
+    std::unique_ptr<LinkAction> getFormAdditionalAction(FormAdditionalActionsType type);
+    Dict *getParent() { return parent; }
+
+    bool setFormAdditionalAction(FormAdditionalActionsType type, const std::string &js);
+
+    void setField(FormField *f) { field = f; };
+
+private:
+    void initialize(PDFDoc *docA, Dict *dict);
+
+    Form *form;
+    FormField *field; // FormField object for this annotation
+    AnnotWidgetHighlightMode mode; // H  (Default I)
+    std::unique_ptr<AnnotAppearanceCharacs> appearCharacs; // MK
+    std::unique_ptr<LinkAction> action; // A
+    Object additionalActions; // AA
+    // inherited  from Annot
+    // AnnotBorderBS border;                // BS
+    Dict *parent; // Parent
+    Ref updatedAppearanceStream; // {-1,-1} if updateAppearanceStream has never been called
+};
+
+//------------------------------------------------------------------------
+// Annot3D
+//------------------------------------------------------------------------
+
+class Annot3D : public Annot
+{
+    class Activation
+    {
+    public:
+        enum ActivationATrigger
+        {
+            aTriggerUnknown,
+            aTriggerPageOpened, // PO
+            aTriggerPageVisible, // PV
+            aTriggerUserAction // XA
+        };
+
+        enum ActivationAState
+        {
+            aStateUnknown,
+            aStateEnabled, // I
+            aStateDisabled // L
+        };
+
+        enum ActivationDTrigger
+        {
+            dTriggerUnknown,
+            dTriggerPageClosed, // PC
+            dTriggerPageInvisible, // PI
+            dTriggerUserAction // XD
+        };
+
+        enum ActivationDState
+        {
+            dStateUnknown,
+            dStateUninstantiaded, // U
+            dStateInstantiated, // I
+            dStateLive // L
+        };
+
+        explicit Activation(Dict *dict);
+
+    private:
+        ActivationATrigger aTrigger; // A   (Default XA)
+        ActivationAState aState; // AIS (Default L)
+        ActivationDTrigger dTrigger; // D   (Default PI)
+        ActivationDState dState; // DIS (Default U)
+        bool displayToolbar; // TB  (Default true)
+        bool displayNavigation; // NP  (Default false);
+    };
+
+public:
+    Annot3D(PDFDoc *docA, PDFRectangle *rect);
+    Annot3D(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~Annot3D() override;
+
+    // getters
+
+private:
+    void initialize(PDFDoc *docA, Dict *dict);
+
+    std::unique_ptr<Activation> activation; // 3DA
+};
+
+//------------------------------------------------------------------------
+// AnnotRichMedia
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT AnnotRichMedia : public Annot
+{
+public:
+    class POPPLER_PRIVATE_EXPORT Params
+    {
+    public:
+        explicit Params(Dict *dict);
+        ~Params();
+
+        Params(const Params &) = delete;
+        Params &operator=(const Params &) = delete;
+
+        const GooString *getFlashVars() const;
+
+    private:
+        // optional
+        std::unique_ptr<GooString> flashVars; // FlashVars
+    };
+
+    class POPPLER_PRIVATE_EXPORT Instance
+    {
+    public:
+        enum Type
+        {
+            type3D, // 3D
+            typeFlash, // Flash
+            typeSound, // Sound
+            typeVideo // Video
+        };
+
+        explicit Instance(Dict *dict);
+        ~Instance();
+
+        Instance(const Instance &) = delete;
+        Instance &operator=(const Instance &) = delete;
+
+        Type getType() const;
+        Params *getParams() const;
+
+    private:
+        // optional
+        Type type; // Subtype
+        std::unique_ptr<Params> params; // Params
+    };
+
+    class POPPLER_PRIVATE_EXPORT Configuration
+    {
+    public:
+        enum Type
+        {
+            type3D, // 3D
+            typeFlash, // Flash
+            typeSound, // Sound
+            typeVideo // Video
+        };
+
+        explicit Configuration(Dict *dict);
+        ~Configuration();
+
+        Configuration(const Configuration &) = delete;
+        Configuration &operator=(const Configuration &) = delete;
+
+        Type getType() const;
+        const GooString *getName() const;
+        int getInstancesCount() const;
+        Instance *getInstance(int index) const;
+
+    private:
+        // optional
+        Type type; // Subtype
+        std::unique_ptr<GooString> name; // Name
+        Instance **instances; // Instances
+        int nInstances;
+    };
+
+    class Content;
+
+    class POPPLER_PRIVATE_EXPORT Asset
+    {
+    public:
+        Asset();
+        ~Asset();
+
+        Asset(const Asset &) = delete;
+        Asset &operator=(const Asset &) = delete;
+
+        const GooString *getName() const;
+        Object *getFileSpec() const;
+
+    private:
+        friend class AnnotRichMedia::Content;
+
+        std::unique_ptr<GooString> name;
+        Object fileSpec;
+    };
+
+    class POPPLER_PRIVATE_EXPORT Content
+    {
+    public:
+        explicit Content(Dict *dict);
+        ~Content();
+
+        Content(const Content &) = delete;
+        Content &operator=(const Content &) = delete;
+
+        int getConfigurationsCount() const;
+        Configuration *getConfiguration(int index) const;
+
+        int getAssetsCount() const;
+        Asset *getAsset(int index) const;
+
+    private:
+        // optional
+        Configuration **configurations; // Configurations
+        int nConfigurations;
+
+        Asset **assets; // Assets
+        int nAssets;
+    };
+
+    class POPPLER_PRIVATE_EXPORT Activation
+    {
+    public:
+        enum Condition
+        {
+            conditionPageOpened, // PO
+            conditionPageVisible, // PV
+            conditionUserAction // XA
+        };
+
+        explicit Activation(Dict *dict);
+
+        Condition getCondition() const;
+
+    private:
+        // optional
+        Condition condition;
+    };
+
+    class POPPLER_PRIVATE_EXPORT Deactivation
+    {
+    public:
+        enum Condition
+        {
+            conditionPageClosed, // PC
+            conditionPageInvisible, // PI
+            conditionUserAction // XD
+        };
+
+        explicit Deactivation(Dict *dict);
+
+        Condition getCondition() const;
+
+    private:
+        // optional
+        Condition condition;
+    };
+
+    class POPPLER_PRIVATE_EXPORT Settings
+    {
+    public:
+        explicit Settings(Dict *dict);
+        ~Settings();
+
+        Settings(const Settings &) = delete;
+        Settings &operator=(const Settings &) = delete;
+
+        Activation *getActivation() const;
+        Deactivation *getDeactivation() const;
+
+    private:
+        // optional
+        std::unique_ptr<Activation> activation;
+        std::unique_ptr<Deactivation> deactivation;
+    };
+
+    AnnotRichMedia(PDFDoc *docA, PDFRectangle *rect);
+    AnnotRichMedia(PDFDoc *docA, Object &&dictObject, const Object *obj);
+    ~AnnotRichMedia() override;
+
+    Content *getContent() const;
+
+    Settings *getSettings() const;
+
+private:
+    void initialize(PDFDoc *docA, Dict *dict);
+
+    // required
+    std::unique_ptr<Content> content; // RichMediaContent
+
+    // optional
+    std::unique_ptr<Settings> settings; // RichMediaSettings
+};
+
+//------------------------------------------------------------------------
+// Annots
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT Annots
+{
+public:
+    // Build a list of Annot objects and call setPage on them
+    Annots(PDFDoc *docA, int page, Object *annotsObj);
+
+    ~Annots();
+
+    Annots(const Annots &) = delete;
+    Annots &operator=(const Annots &) = delete;
+
+    const std::vector<Annot *> &getAnnots() { return annots; }
+
+    void appendAnnot(Annot *annot);
+    bool removeAnnot(Annot *annot);
+
+private:
+    Annot *createAnnot(Object &&dictObject, const Object *obj);
+    Annot *findAnnot(Ref *ref);
+
+    PDFDoc *doc;
+    std::vector<Annot *> annots;
+};
+
+#endif

poppler-23.11.0/Library/include/poppler/AnnotStampImageHelper.h

@@ -0,0 +1,68 @@
+//========================================================================
+//
+// AnnotStampImageHelper.h
+//
+// Copyright (C) 2021 Mahmoud Ahmed Khalil <[email protected]>
+// Copyright (C) 2021 Albert Astals Cid <[email protected]>
+//
+// Licensed under GPLv2 or later
+//
+//========================================================================
+
+#ifndef ANNOTSTAMPIMAGEHELPER_H
+#define ANNOTSTAMPIMAGEHELPER_H
+
+#include "Object.h"
+
+class PDFDoc;
+
+enum ColorSpace
+{
+    DeviceGray,
+    DeviceRGB,
+    DeviceCMYK
+};
+
+/**
+ * This class is used only to load Image XObjects into stamp annotations. It takes in
+ * the image parameters in its constructors and creates a new Image XObject that gets
+ * added to the XRef table, so that the annotations that would like to use it be able
+ * to get its ref number.
+ *
+ * To have transparency in the image, you should first try to create the soft
+ * mask of the image, by creating a AnnotStampImageHelper object giving it the soft
+ * image data normally. You would then need to pass in the created soft mask Image XObject
+ * ref to the actual image you'd like to be created by this helper class.
+ */
+class POPPLER_PRIVATE_EXPORT AnnotStampImageHelper
+{
+public:
+    AnnotStampImageHelper(PDFDoc *docA, int widthA, int heightA, ColorSpace colorSpace, int bitsPerComponent, char *data, int dataLength);
+    AnnotStampImageHelper(PDFDoc *docA, int widthA, int heightA, ColorSpace colorSpace, int bitsPerComponent, char *data, int dataLength, Ref softMaskRef);
+    ~AnnotStampImageHelper() { }
+
+    // Returns the ref to the created Image XObject
+    Ref getRef() const { return ref; }
+
+    // Returns the width of the image
+    int getWidth() const { return width; }
+    // Returns the height of the image
+    int getHeight() const { return height; }
+
+    // Removes the created Image XObject as well as its soft mask from the XRef Table
+    void removeAnnotStampImageObject();
+
+private:
+    void initialize(PDFDoc *docA, int widthA, int heightA, ColorSpace colorSpace, int bitsPerComponent, char *data, int dataLength);
+
+    PDFDoc *doc;
+
+    Object imgObj;
+    Ref ref;
+    Ref sMaskRef;
+
+    int width;
+    int height;
+};
+
+#endif

poppler-23.11.0/Library/include/poppler/Array.h

@@ -0,0 +1,92 @@
+//========================================================================
+//
+// Array.h
+//
+// Copyright 1996-2003 Glyph & Cog, LLC
+//
+//========================================================================
+
+//========================================================================
+//
+// Modified under the Poppler project - http://poppler.freedesktop.org
+//
+// All changes made under the Poppler project to this file are licensed
+// under GPL version 2 or later
+//
+// Copyright (C) 2005 Kristian Høgsberg <[email protected]>
+// Copyright (C) 2012 Fabio D'Urso <[email protected]>
+// Copyright (C) 2013 Thomas Freitag <[email protected]>
+// Copyright (C) 2017-2019, 2021 Albert Astals Cid <[email protected]>
+// Copyright (C) 2017 Adrian Johnson <[email protected]>
+// Copyright (C) 2018, 2019 Adam Reichold <[email protected]>
+//
+// To see a description of the changes please see the Changelog file that
+// came with your tarball or type make ChangeLog if you are building from git
+//
+//========================================================================
+
+#ifndef ARRAY_H
+#define ARRAY_H
+
+#include <atomic>
+#include <mutex>
+#include <vector>
+
+#include "poppler-config.h"
+#include "poppler_private_export.h"
+#include "Object.h"
+
+class XRef;
+
+//------------------------------------------------------------------------
+// Array
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT Array
+{
+public:
+    // Constructor.
+    explicit Array(XRef *xrefA);
+
+    // Destructor.
+    ~Array();
+
+    Array(const Array &) = delete;
+    Array &operator=(const Array &) = delete;
+
+    // Get number of elements.
+    int getLength() const { return elems.size(); }
+
+    // Copy array with new xref
+    Array *copy(XRef *xrefA) const;
+
+    Array *deepCopy() const;
+
+    // Add an element
+    // elem becomes a dead object after this call
+    void add(Object &&elem);
+
+    // Remove an element by position
+    void remove(int i);
+
+    // Accessors.
+    Object get(int i, int recursion = 0) const;
+    // Same as above but if the returned object is a fetched Ref returns such Ref in returnRef, otherwise returnRef is Ref::INVALID()
+    Object get(int i, Ref *returnRef, int recursion = 0) const;
+    const Object &getNF(int i) const;
+    bool getString(int i, GooString *string) const;
+
+private:
+    friend class Object; // for incRef/decRef
+
+    // Reference counting.
+    int incRef() { return ++ref; }
+    int decRef() { return --ref; }
+
+    XRef *xref; // the xref table for this PDF file
+    std::vector<Object> elems; // array of elements
+    std::atomic_int ref; // reference count
+    mutable std::recursive_mutex mutex;
+};
+
+#endif

poppler-23.11.0/Library/include/poppler/BBoxOutputDev.h

@@ -0,0 +1,54 @@
+//========================================================================
+//
+// BBoxOutputDev.cc
+//
+// This file is licensed under the GPLv2 or later
+//
+// Copyright 2020 sgerwk <[email protected]>
+//
+//========================================================================
+
+#include <PDFDoc.h>
+#include <GfxState.h>
+#include <OutputDev.h>
+
+class POPPLER_PRIVATE_EXPORT BBoxOutputDev : public OutputDev
+{
+public:
+    bool upsideDown() override { return false; }
+    bool useDrawChar() override { return true; }
+    bool interpretType3Chars() override { return false; }
+
+    BBoxOutputDev();
+    BBoxOutputDev(bool text, bool vector, bool raster);
+    BBoxOutputDev(bool text, bool vector, bool raster, bool lwidth);
+    void endPage() override;
+    void stroke(GfxState *state) override;
+    void fill(GfxState *state) override;
+    void eoFill(GfxState *state) override;
+    void drawChar(GfxState *state, double x, double y, double dx, double dy, double originX, double originY, CharCode code, int nBytes, const Unicode *u, int uLen) override;
+    void drawImageMask(GfxState *state, Object *ref, Stream *str, int width, int height, bool invert, bool interpolate, bool inlineImg) override;
+    void drawImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, bool interpolate, const int *maskColors, bool inlineImg) override;
+    void drawMaskedImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, bool interpolate, Stream *maskStr, int maskWidth, int maskHeight, bool maskInvert, bool maskInterpolate) override;
+    void drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, bool interpolate, Stream *maskStr, int maskWidth, int maskHeight, GfxImageColorMap *maskColorMap,
+                             bool maskInterpolate) override;
+
+    double getX1() const;
+    double getY1() const;
+    double getX2() const;
+    double getY2() const;
+    double getHasGraphics() const;
+
+private:
+    PDFRectangle bb;
+    bool hasGraphics;
+
+    bool text;
+    bool vector;
+    bool raster;
+    bool lwidth;
+
+    void updatePoint(PDFRectangle *bbA, double x, double y, const GfxState *state);
+    void updatePath(PDFRectangle *bbA, const GfxPath *path, const GfxState *state);
+    void updateImage(PDFRectangle *bbA, const GfxState *state);
+};

poppler-23.11.0/Library/include/poppler/CMap.h

@@ -0,0 +1,128 @@
+//========================================================================
+//
+// CMap.h
+//
+// Copyright 2001-2003 Glyph & Cog, LLC
+//
+//========================================================================
+
+//========================================================================
+//
+// Modified under the Poppler project - http://poppler.freedesktop.org
+//
+// All changes made under the Poppler project to this file are licensed
+// under GPL version 2 or later
+//
+// Copyright (C) 2008 Koji Otani <[email protected]>
+// Copyright (C) 2009, 2018-2020, 2022 Albert Astals Cid <[email protected]>
+// Copyright (C) 2012, 2017 Adrian Johnson <[email protected]>
+// Copyright (C) 2018 Adam Reichold <[email protected]>
+//
+// To see a description of the changes please see the Changelog file that
+// came with your tarball or type make ChangeLog if you are building from git
+//
+//========================================================================
+
+#ifndef CMAP_H
+#define CMAP_H
+
+#include <array>
+#include <atomic>
+#include <memory>
+
+#include "poppler-config.h"
+#include "CharTypes.h"
+
+class GooString;
+class Object;
+struct CMapVectorEntry;
+class CMapCache;
+class Stream;
+
+//------------------------------------------------------------------------
+
+class CMap
+{
+public:
+    // Parse a CMap from <obj>, which can be a name or a stream.  Sets
+    // the initial reference count to 1.  Returns NULL on failure.
+    static std::shared_ptr<CMap> parse(CMapCache *cache, const GooString *collectionA, Object *obj);
+
+    // Create the CMap specified by <collection> and <cMapName>.  Sets
+    // the initial reference count to 1.  Returns NULL on failure.
+    static std::shared_ptr<CMap> parse(CMapCache *cache, const GooString *collectionA, const GooString *cMapNameA);
+
+    // Parse a CMap from <str>.  Sets the initial reference count to 1.
+    // Returns NULL on failure.
+    static std::shared_ptr<CMap> parse(CMapCache *cache, const GooString *collectionA, Stream *str);
+
+    ~CMap();
+
+    CMap(const CMap &) = delete;
+    CMap &operator=(const CMap &) = delete;
+
+    // Return collection name (<registry>-<ordering>).
+    const GooString *getCollection() const { return collection; }
+
+    const GooString *getCMapName() const { return cMapName; }
+
+    // Return true if this CMap matches the specified <collectionA>, and
+    // <cMapNameA>.
+    bool match(const GooString *collectionA, const GooString *cMapNameA);
+
+    // Return the CID corresponding to the character code starting at
+    // <s>, which contains <len> bytes.  Sets *<c> to the char code, and
+    // *<nUsed> to the number of bytes used by the char code.
+    CID getCID(const char *s, int len, CharCode *c, int *nUsed);
+
+    // Return the writing mode (0=horizontal, 1=vertical).
+    int getWMode() const { return wMode; }
+
+    void setReverseMap(unsigned int *rmap, unsigned int rmapSize, unsigned int ncand);
+
+private:
+    void parse2(CMapCache *cache, int (*getCharFunc)(void *), void *data);
+    CMap(GooString *collectionA, GooString *cMapNameA);
+    CMap(GooString *collectionA, GooString *cMapNameA, int wModeA);
+    void useCMap(CMapCache *cache, const char *useName);
+    void useCMap(CMapCache *cache, Object *obj);
+    void copyVector(CMapVectorEntry *dest, CMapVectorEntry *src);
+    void addCIDs(unsigned int start, unsigned int end, unsigned int nBytes, CID firstCID);
+    void freeCMapVector(CMapVectorEntry *vec);
+    void setReverseMapVector(unsigned int startCode, CMapVectorEntry *vec, unsigned int *rmap, unsigned int rmapSize, unsigned int ncand);
+
+    GooString *collection;
+    GooString *cMapName;
+    bool isIdent; // true if this CMap is an identity mapping,
+                  //   or is based on one (via usecmap)
+    int wMode; // writing mode (0=horizontal, 1=vertical)
+    CMapVectorEntry *vector; // vector for first byte (NULL for
+                             //   identity CMap)
+};
+
+//------------------------------------------------------------------------
+
+#define cMapCacheSize 4
+
+class CMapCache
+{
+public:
+    CMapCache();
+    ~CMapCache() = default;
+
+    CMapCache(const CMapCache &) = delete;
+    CMapCache &operator=(const CMapCache &) = delete;
+
+    // Get the <cMapName> CMap for the specified character collection.
+    // Increments its reference count; there will be one reference for
+    // the cache plus one for the caller of this function.
+    // Stream is a stream containing the CMap, can be NULL and
+    // this means the CMap will be searched in the CMap files
+    // Returns NULL on failure.
+    std::shared_ptr<CMap> getCMap(const GooString *collection, const GooString *cMapName);
+
+private:
+    std::array<std::shared_ptr<CMap>, cMapCacheSize> cache;
+};
+
+#endif

poppler-23.11.0/Library/include/poppler/CachedFile.h

@@ -0,0 +1,149 @@
+//========================================================================
+//
+// CachedFile.h
+//
+// Caching files support.
+//
+// This file is licensed under the GPLv2 or later
+//
+// Copyright 2009 Stefan Thomas <[email protected]>
+// Copyright 2010 Hib Eris <[email protected]>
+// Copyright 2010, 2018-2020, 2022 Albert Astals Cid <[email protected]>
+//
+//========================================================================
+
+#ifndef CACHEDFILE_H
+#define CACHEDFILE_H
+
+#include "poppler-config.h"
+#include "poppler_private_export.h"
+
+#include "Object.h"
+#include "Stream.h"
+
+#include <vector>
+
+//------------------------------------------------------------------------
+
+#define CachedFileChunkSize 8192 // This should be a multiple of cachedStreamBufSize
+
+class GooString;
+class CachedFileLoader;
+
+//------------------------------------------------------------------------
+// CachedFile
+//
+// CachedFile gives FILE-like access to a document at a specified URI.
+// In the constructor, you specify a CachedFileLoader that handles loading
+// the data from the document. The CachedFile requests no more data then it
+// needs from the CachedFileLoader.
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT CachedFile
+{
+
+    friend class CachedFileWriter;
+
+public:
+    explicit CachedFile(CachedFileLoader *cacheLoader);
+
+    CachedFile(const CachedFile &) = delete;
+    CachedFile &operator=(const CachedFile &) = delete;
+
+    unsigned int getLength() const { return length; }
+    long int tell();
+    int seek(long int offset, int origin);
+    size_t read(void *ptr, size_t unitsize, size_t count);
+    size_t write(const char *ptr, size_t size, size_t fromByte);
+    int cache(const std::vector<ByteRange> &ranges);
+
+    // Reference counting.
+    void incRefCnt();
+    void decRefCnt();
+
+private:
+    ~CachedFile();
+
+    enum ChunkState
+    {
+        chunkStateNew = 0,
+        chunkStateLoaded
+    };
+
+    typedef struct
+    {
+        ChunkState state;
+        char data[CachedFileChunkSize];
+    } Chunk;
+
+    int cache(size_t offset, size_t length);
+
+    CachedFileLoader *loader;
+
+    size_t length;
+    size_t streamPos;
+
+    std::vector<Chunk> *chunks;
+
+    int refCnt; // reference count
+};
+
+//------------------------------------------------------------------------
+// CachedFileWriter
+//
+// CachedFileWriter handles sequential writes to a CachedFile.
+// On construction, you specify the CachedFile and the chunks of it to which data
+// should be written.
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT CachedFileWriter
+{
+
+public:
+    // Construct a CachedFile Writer.
+    // The caller is responsible for deleting the cachedFile and chunksA.
+    CachedFileWriter(CachedFile *cachedFile, std::vector<int> *chunksA);
+
+    ~CachedFileWriter();
+
+    // Writes size bytes from ptr to cachedFile, returns number of bytes written.
+    size_t write(const char *ptr, size_t size);
+
+private:
+    CachedFile *cachedFile;
+    std::vector<int> *chunks;
+    std::vector<int>::iterator it;
+    size_t offset;
+};
+
+//------------------------------------------------------------------------
+// CachedFileLoader
+//
+// CachedFileLoader is an abstact class that specifies the interface for
+// loadng data from an URI into a CachedFile.
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT CachedFileLoader
+{
+
+public:
+    CachedFileLoader() = default;
+    virtual ~CachedFileLoader();
+
+    CachedFileLoader(const CachedFileLoader &) = delete;
+    CachedFileLoader &operator=(const CachedFileLoader &) = delete;
+
+    // Initializes the file load.
+    // Returns the length of the file.
+    // The caller is responsible for deleting cachedFile.
+    virtual size_t init(CachedFile *cachedFile) = 0;
+
+    // Loads specified byte ranges and passes it to the writer to store them.
+    // Returns 0 on success, Anything but 0 on failure.
+    // The caller is responsible for deleting the writer.
+    virtual int load(const std::vector<ByteRange> &ranges, CachedFileWriter *writer) = 0;
+};
+
+//------------------------------------------------------------------------
+
+#endif

poppler-23.11.0/Library/include/poppler/CairoFontEngine.h

@@ -0,0 +1,143 @@
+//========================================================================
+//
+// CairoFontEngine.h
+//
+// Copyright 2003 Glyph & Cog, LLC
+// Copyright 2004 Red Hat, Inc
+//
+//========================================================================
+
+//========================================================================
+//
+// Modified under the Poppler project - http://poppler.freedesktop.org
+//
+// All changes made under the Poppler project to this file are licensed
+// under GPL version 2 or later
+//
+// Copyright (C) 2005, 2006 Kristian Høgsberg <[email protected]>
+// Copyright (C) 2005, 2018, 2019, 2021 Albert Astals Cid <[email protected]>
+// Copyright (C) 2006, 2007 Jeff Muizelaar <[email protected]>
+// Copyright (C) 2006, 2010 Carlos Garcia Campos <[email protected]>
+// Copyright (C) 2008, 2017, 2022 Adrian Johnson <[email protected]>
+// Copyright (C) 2013 Thomas Freitag <[email protected]>
+// Copyright (C) 2018 Adam Reichold <[email protected]>
+// Copyright (C) 2022 Oliver Sander <[email protected]>
+// Copyright (C) 2022 Marek Kasik <[email protected]>
+//
+// To see a description of the changes please see the Changelog file that
+// came with your tarball or type make ChangeLog if you are building from git
+//
+//========================================================================
+
+#ifndef CAIROFONTENGINE_H
+#define CAIROFONTENGINE_H
+
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+#include <vector>
+
+#include "poppler-config.h"
+#include <cairo-ft.h>
+
+#include "GfxFont.h"
+#include "PDFDoc.h"
+
+class CairoFontEngine;
+
+class CairoFont
+{
+public:
+    CairoFont(Ref refA, cairo_font_face_t *cairo_font_faceA, std::vector<int> &&codeToGIDA, bool substituteA, bool printingA);
+    virtual ~CairoFont();
+    CairoFont(const CairoFont &) = delete;
+    CairoFont &operator=(const CairoFont &other) = delete;
+
+    virtual bool matches(Ref &other, bool printing);
+    cairo_font_face_t *getFontFace();
+    unsigned long getGlyph(CharCode code, const Unicode *u, int uLen);
+    double getSubstitutionCorrection(const std::shared_ptr<GfxFont> &gfxFont);
+
+    bool isSubstitute() { return substitute; }
+
+    Ref getRef() { return ref; }
+
+protected:
+    Ref ref;
+    cairo_font_face_t *cairo_font_face;
+
+    std::vector<int> codeToGID;
+
+    bool substitute;
+    bool printing;
+};
+
+//------------------------------------------------------------------------
+
+struct FreeTypeFontFace
+{
+    FT_Face face;
+    cairo_font_face_t *cairo_font_face;
+};
+
+class CairoFreeTypeFont : public CairoFont
+{
+public:
+    static CairoFreeTypeFont *create(const std::shared_ptr<GfxFont> &gfxFont, XRef *xref, FT_Library lib, CairoFontEngine *fontEngine, bool useCIDs);
+    ~CairoFreeTypeFont() override;
+
+private:
+    CairoFreeTypeFont(Ref ref, cairo_font_face_t *cairo_font_face, std::vector<int> &&codeToGID, bool substitute);
+
+    static std::optional<FreeTypeFontFace> getFreeTypeFontFace(CairoFontEngine *fontEngine, FT_Library lib, const std::string &filename, std::vector<unsigned char> &&data);
+};
+
+//------------------------------------------------------------------------
+
+class CairoType3Font : public CairoFont
+{
+public:
+    static CairoType3Font *create(const std::shared_ptr<GfxFont> &gfxFont, PDFDoc *doc, CairoFontEngine *fontEngine, bool printing, XRef *xref);
+    ~CairoType3Font() override;
+
+    bool matches(Ref &other, bool printing) override;
+
+private:
+    CairoType3Font(Ref ref, cairo_font_face_t *cairo_font_face, std::vector<int> &&codeToGIDA, bool printing, XRef *xref);
+};
+
+//------------------------------------------------------------------------
+
+//------------------------------------------------------------------------
+// CairoFontEngine
+//------------------------------------------------------------------------
+
+class CairoFontEngine
+{
+public:
+    // Create a font engine.
+    explicit CairoFontEngine(FT_Library libA);
+    ~CairoFontEngine();
+    CairoFontEngine(const CairoFontEngine &) = delete;
+    CairoFontEngine &operator=(const CairoFontEngine &other) = delete;
+
+    std::shared_ptr<CairoFont> getFont(const std::shared_ptr<GfxFont> &gfxFont, PDFDoc *doc, bool printing, XRef *xref);
+
+    static std::optional<FreeTypeFontFace> getExternalFontFace(FT_Library ftlib, const std::string &filename);
+
+private:
+    FT_Library lib;
+    bool useCIDs;
+    mutable std::mutex mutex;
+
+    // Cache of CairoFont for current document
+    // Most recently used is at the end of the vector.
+    static const size_t cairoFontCacheSize = 64;
+    std::vector<std::shared_ptr<CairoFont>> fontCache;
+
+    // Global cache of cairo_font_face_t for external font files.
+    static std::unordered_map<std::string, FreeTypeFontFace> fontFileCache;
+    static std::recursive_mutex fontFileCacheMutex;
+};
+
+#endif

poppler-23.11.0/Library/include/poppler/CairoOutputDev.h

@@ -0,0 +1,537 @@
+//========================================================================
+//
+// CairoOutputDev.h
+//
+// Copyright 2003 Glyph & Cog, LLC
+// Copyright 2004 Red Hat, INC
+//
+//========================================================================
+
+//========================================================================
+//
+// Modified under the Poppler project - http://poppler.freedesktop.org
+//
+// All changes made under the Poppler project to this file are licensed
+// under GPL version 2 or later
+//
+// Copyright (C) 2005-2008 Jeff Muizelaar <[email protected]>
+// Copyright (C) 2005, 2006 Kristian Høgsberg <[email protected]>
+// Copyright (C) 2005 Nickolay V. Shmyrev <[email protected]>
+// Copyright (C) 2006-2011, 2013 Carlos Garcia Campos <[email protected]>
+// Copyright (C) 2008, 2009, 2011-2017, 2022, 2023 Adrian Johnson <[email protected]>
+// Copyright (C) 2008 Michael Vrable <[email protected]>
+// Copyright (C) 2010-2013 Thomas Freitag <[email protected]>
+// Copyright (C) 2015 Suzuki Toshiya <[email protected]>
+// Copyright (C) 2016 Jason Crain <[email protected]>
+// Copyright (C) 2018, 2019, 2021 Albert Astals Cid <[email protected]>
+// Copyright (C) 2018 Klarälvdalens Datakonsult AB, a KDAB Group company, <[email protected]>. Work sponsored by the LiMux project of the city of Munich
+// Copyright (C) 2020 Michal <[email protected]>
+// Copyright (C) 2021 Christian Persch <[email protected]>
+// Copyright (C) 2022 Marek Kasik <[email protected]>
+//
+// To see a description of the changes please see the Changelog file that
+// came with your tarball or type make ChangeLog if you are building from git
+//
+//========================================================================
+
+#ifndef CAIROOUTPUTDEV_H
+#define CAIROOUTPUTDEV_H
+
+#include <unordered_set>
+
+#include <cairo-ft.h>
+#include "OutputDev.h"
+#include "TextOutputDev.h"
+#include "GfxState.h"
+#include "StructElement.h"
+#include "StructTreeRoot.h"
+#include "Annot.h"
+#include "Link.h"
+
+class PDFDoc;
+class GfxState;
+class GfxPath;
+class Gfx8BitFont;
+struct GfxRGB;
+class CairoFontEngine;
+class CairoFont;
+
+//------------------------------------------------------------------------
+
+//------------------------------------------------------------------------
+// CairoImage
+//------------------------------------------------------------------------
+class CairoImage
+{
+public:
+    // Constructor.
+    CairoImage(double x1, double y1, double x2, double y2);
+
+    // Destructor.
+    ~CairoImage();
+
+    CairoImage(const CairoImage &) = delete;
+    CairoImage &operator=(const CairoImage &) = delete;
+
+    // Set the image cairo surface
+    void setImage(cairo_surface_t *image);
+
+    // Get the image cairo surface
+    cairo_surface_t *getImage() const { return image; }
+
+    // Get the image rectangle
+    void getRect(double *xa1, double *ya1, double *xa2, double *ya2)
+    {
+        *xa1 = x1;
+        *ya1 = y1;
+        *xa2 = x2;
+        *ya2 = y2;
+    }
+
+private:
+    cairo_surface_t *image; // image cairo surface
+    double x1, y1; // upper left corner
+    double x2, y2; // lower right corner
+};
+
+//------------------------------------------------------------------------
+// CairoOutputDev
+//------------------------------------------------------------------------
+
+class CairoOutputDev : public OutputDev
+{
+public:
+    // Constructor.
+    CairoOutputDev();
+
+    // Destructor.
+    ~CairoOutputDev() override;
+
+    //----- get info about output device
+
+    // Does this device use upside-down coordinates?
+    // (Upside-down means (0,0) is the top left corner of the page.)
+    bool upsideDown() override { return true; }
+
+    // Does this device use drawChar() or drawString()?
+    bool useDrawChar() override { return true; }
+
+    // Does this device use tilingPatternFill()?  If this returns false,
+    // tiling pattern fills will be reduced to a series of other drawing
+    // operations.
+    bool useTilingPatternFill() override { return true; }
+
+    // Does this device use functionShadedFill(), axialShadedFill(), and
+    // radialShadedFill()?  If this returns false, these shaded fills
+    // will be reduced to a series of other drawing operations.
+#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 12, 0)
+    bool useShadedFills(int type) override { return type <= 7; }
+#else
+    bool useShadedFills(int type) override { return type > 1 && type < 4; }
+#endif
+
+    // Does this device use FillColorStop()?
+    bool useFillColorStop() override { return true; }
+
+    // Does this device use beginType3Char/endType3Char?  Otherwise,
+    // text in Type 3 fonts will be drawn with drawChar/drawString.
+    bool interpretType3Chars() override { return false; }
+
+    // Does this device need to clip pages to the crop box even when the
+    // box is the crop box?
+    bool needClipToCropBox() override { return true; }
+
+    //----- initialization and control
+
+    // Start a page.
+    void startPage(int pageNum, GfxState *state, XRef *xref) override;
+
+    // End a page.
+    void endPage() override;
+
+    // Must be called before last call to endPage()
+    void emitStructTree();
+
+    void beginForm(Object *obj, Ref id) override;
+    void endForm(Object *obj, Ref id) override;
+
+    //----- save/restore graphics state
+    void saveState(GfxState *state) override;
+    void restoreState(GfxState *state) override;
+
+    //----- update graphics state
+    void updateAll(GfxState *state) override;
+    void setDefaultCTM(const double *ctm) override;
+    void updateCTM(GfxState *state, double m11, double m12, double m21, double m22, double m31, double m32) override;
+    void updateLineDash(GfxState *state) override;
+    void updateFlatness(GfxState *state) override;
+    void updateLineJoin(GfxState *state) override;
+    void updateLineCap(GfxState *state) override;
+    void updateMiterLimit(GfxState *state) override;
+    void updateLineWidth(GfxState *state) override;
+    void updateFillColor(GfxState *state) override;
+    void updateStrokeColor(GfxState *state) override;
+    void updateFillOpacity(GfxState *state) override;
+    void updateStrokeOpacity(GfxState *state) override;
+    void updateFillColorStop(GfxState *state, double offset) override;
+    void updateBlendMode(GfxState *state) override;
+
+    //----- update text state
+    void updateFont(GfxState *state) override;
+
+    //----- path painting
+    void stroke(GfxState *state) override;
+    void fill(GfxState *state) override;
+    void eoFill(GfxState *state) override;
+    void clipToStrokePath(GfxState *state) override;
+    bool tilingPatternFill(GfxState *state, Gfx *gfx, Catalog *cat, GfxTilingPattern *tPat, const double *mat, int x0, int y0, int x1, int y1, double xStep, double yStep) override;
+#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 12, 0)
+    bool functionShadedFill(GfxState *state, GfxFunctionShading *shading) override;
+#endif
+    bool axialShadedFill(GfxState *state, GfxAxialShading *shading, double tMin, double tMax) override;
+    bool axialShadedSupportExtend(GfxState *state, GfxAxialShading *shading) override;
+    bool radialShadedFill(GfxState *state, GfxRadialShading *shading, double sMin, double sMax) override;
+    bool radialShadedSupportExtend(GfxState *state, GfxRadialShading *shading) override;
+#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 12, 0)
+    bool gouraudTriangleShadedFill(GfxState *state, GfxGouraudTriangleShading *shading) override;
+    bool patchMeshShadedFill(GfxState *state, GfxPatchMeshShading *shading) override;
+#endif
+
+    //----- path clipping
+    void clip(GfxState *state) override;
+    void eoClip(GfxState *state) override;
+
+    //----- text drawing
+    void beginString(GfxState *state, const GooString *s) override;
+    void endString(GfxState *state) override;
+    void drawChar(GfxState *state, double x, double y, double dx, double dy, double originX, double originY, CharCode code, int nBytes, const Unicode *u, int uLen) override;
+    void beginActualText(GfxState *state, const GooString *text) override;
+    void endActualText(GfxState *state) override;
+
+    bool beginType3Char(GfxState *state, double x, double y, double dx, double dy, CharCode code, const Unicode *u, int uLen) override;
+    void endType3Char(GfxState *state) override;
+    void beginTextObject(GfxState *state) override;
+    void endTextObject(GfxState *state) override;
+
+    void beginMarkedContent(const char *name, Dict *properties) override;
+    void endMarkedContent(GfxState *state) override;
+
+    //----- image drawing
+    void drawImageMask(GfxState *state, Object *ref, Stream *str, int width, int height, bool invert, bool interpolate, bool inlineImg) override;
+    void setSoftMaskFromImageMask(GfxState *state, Object *ref, Stream *str, int width, int height, bool invert, bool inlineImg, double *baseMatrix) override;
+    void unsetSoftMaskFromImageMask(GfxState *state, double *baseMatrix) override;
+    void drawImageMaskPrescaled(GfxState *state, Object *ref, Stream *str, int width, int height, bool invert, bool interpolate, bool inlineImg);
+    void drawImageMaskRegular(GfxState *state, Object *ref, Stream *str, int width, int height, bool invert, bool interpolate, bool inlineImg);
+
+    void drawImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, bool interpolate, const int *maskColors, bool inlineImg) override;
+    void drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, bool interpolate, Stream *maskStr, int maskWidth, int maskHeight, GfxImageColorMap *maskColorMap,
+                             bool maskInterpolate) override;
+
+    void drawMaskedImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, bool interpolate, Stream *maskStr, int maskWidth, int maskHeight, bool maskInvert, bool maskInterpolate) override;
+
+    //----- transparency groups and soft masks
+    void beginTransparencyGroup(GfxState * /*state*/, const double * /*bbox*/, GfxColorSpace * /*blendingColorSpace*/, bool /*isolated*/, bool /*knockout*/, bool /*forSoftMask*/) override;
+    void endTransparencyGroup(GfxState * /*state*/) override;
+    void popTransparencyGroup();
+    void paintTransparencyGroup(GfxState * /*state*/, const double * /*bbox*/) override;
+    void setSoftMask(GfxState * /*state*/, const double * /*bbox*/, bool /*alpha*/, Function * /*transferFunc*/, GfxColor * /*backdropColor*/) override;
+    void clearSoftMask(GfxState * /*state*/) override;
+
+    //----- Type 3 font operators
+    void type3D0(GfxState *state, double wx, double wy) override;
+    void type3D1(GfxState *state, double wx, double wy, double llx, double lly, double urx, double ury) override;
+
+    //----- special access
+
+    // Called to indicate that a new PDF document has been loaded.
+    void startDoc(PDFDoc *docA, CairoFontEngine *fontEngine = nullptr);
+
+    // Called to prepare this output dev for rendering CairoType3Font.
+    void startType3Render(GfxState *state, XRef *xref);
+
+    bool isReverseVideo() { return false; }
+
+    void setCairo(cairo_t *cr);
+    void setTextPage(TextPage *text);
+    void setPrinting(bool printingA)
+    {
+        printing = printingA;
+        needFontUpdate = true;
+    }
+    void copyAntialias(cairo_t *cr, cairo_t *source_cr);
+    void setLogicalStructure(bool logStruct) { this->logicalStruct = logStruct; }
+
+    enum Type3RenderType
+    {
+        Type3RenderNone,
+        Type3RenderMask,
+        Type3RenderColor
+    };
+    void setType3RenderType(Type3RenderType state) { t3_render_state = state; }
+    void getType3GlyphWidth(double *wx, double *wy)
+    {
+        *wx = t3_glyph_wx;
+        *wy = t3_glyph_wy;
+    }
+    bool hasType3GlyphBBox() { return t3_glyph_has_bbox; }
+    double *getType3GlyphBBox() { return t3_glyph_bbox; }
+    bool type3GlyphHasColor() { return t3_glyph_has_color; }
+
+protected:
+    void doPath(cairo_t *cairo, GfxState *state, const GfxPath *path);
+    cairo_surface_t *downscaleSurface(cairo_surface_t *orig_surface);
+    void getScaledSize(const cairo_matrix_t *matrix, int orig_width, int orig_height, int *scaledWidth, int *scaledHeight);
+    cairo_filter_t getFilterForSurface(cairo_surface_t *image, bool interpolate);
+    bool getStreamData(Stream *str, char **buffer, int *length);
+    void setMimeData(GfxState *state, Stream *str, Object *ref, GfxImageColorMap *colorMap, cairo_surface_t *image, int height);
+    void fillToStrokePathClip(GfxState *state);
+    void alignStrokeCoords(const GfxSubpath *subpath, int i, double *x, double *y);
+    AnnotLink *findLinkObject(const StructElement *elem);
+    void quadToCairoRect(AnnotQuadrilaterals *quads, int idx, double destPageHeight, cairo_rectangle_t *rect);
+    bool appendLinkDestRef(GooString *s, const LinkDest *dest);
+    void appendLinkDestXY(GooString *s, const LinkDest *dest, double destPageHeight);
+    bool beginLinkTag(AnnotLink *annotLink);
+    bool beginLink(const StructElement *linkElem);
+    void getStructElemAttributeString(const StructElement *elem);
+    int getContentElementStructParents(const StructElement *element);
+    bool checkIfStructElementNeeded(const StructElement *element);
+    void emitStructElement(const StructElement *elem);
+    void startFirstPage(int pageNum, GfxState *state, XRef *xrefA);
+#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 14, 0)
+    bool setMimeDataForJBIG2Globals(Stream *str, cairo_surface_t *image);
+#endif
+#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 15, 10)
+    bool setMimeDataForCCITTParams(Stream *str, cairo_surface_t *image, int height);
+#endif
+    static void textStringToQuotedUtf8(const GooString *text, GooString *s);
+    bool isPDF();
+
+    std::optional<GfxRGB> fill_color, stroke_color;
+    cairo_pattern_t *fill_pattern, *stroke_pattern;
+    double fill_opacity;
+    double stroke_opacity;
+    bool stroke_adjust;
+    bool adjusted_stroke_width;
+    bool align_stroke_coords;
+    std::shared_ptr<CairoFont> currentFont;
+    XRef *xref;
+
+    struct StrokePathClip
+    {
+        GfxPath *path;
+        cairo_matrix_t ctm;
+        double line_width;
+        double *dashes;
+        int dash_count;
+        double dash_offset;
+        cairo_line_cap_t cap;
+        cairo_line_join_t join;
+        double miter;
+        int ref_count;
+    } *strokePathClip;
+
+    PDFDoc *doc; // the current document
+
+    static FT_Library ft_lib;
+    static std::once_flag ft_lib_once_flag;
+
+    CairoFontEngine *fontEngine;
+    bool fontEngine_owner;
+
+    cairo_t *cairo;
+    cairo_matrix_t orig_matrix;
+    bool needFontUpdate; // set when the font needs to be updated
+    bool printing;
+    bool use_show_text_glyphs;
+    bool text_matrix_valid;
+    cairo_glyph_t *glyphs;
+    int glyphCount;
+    cairo_text_cluster_t *clusters;
+    int clusterCount;
+    char *utf8;
+    int utf8Count;
+    int utf8Max;
+    cairo_path_t *textClipPath;
+    bool inUncoloredPattern; // inside a uncolored pattern (PaintType = 2)
+    Type3RenderType t3_render_state;
+    double t3_glyph_wx, t3_glyph_wy;
+    bool t3_glyph_has_bbox;
+    bool t3_glyph_has_color;
+    bool has_color;
+    double t3_glyph_bbox[4];
+    bool prescaleImages;
+    bool logicalStruct;
+    bool firstPage;
+    int pdfPageNum; // page number of the PDF file
+    int cairoPageNum; // page number in cairo output
+    std::vector<std::string> markedContentStack;
+    std::vector<Annot *> annotations;
+    std::set<std::string> emittedDestinations;
+    std::map<int, int> pdfPageToCairoPageMap;
+
+    TextPage *textPage; // text for the current page
+    ActualText *actualText;
+
+    cairo_pattern_t *group;
+    cairo_pattern_t *shape;
+    cairo_pattern_t *mask;
+    cairo_matrix_t mask_matrix;
+    cairo_t *cairo_shape;
+    int knockoutCount;
+    struct ColorSpaceStack
+    {
+        bool knockout;
+        GfxColorSpace *cs;
+        cairo_matrix_t group_matrix;
+        struct ColorSpaceStack *next;
+    } *groupColorSpaceStack;
+
+    struct SaveStateElement
+    {
+        // These patterns hold a reference
+        cairo_pattern_t *fill_pattern;
+        cairo_pattern_t *stroke_pattern;
+        double fill_opacity;
+        double stroke_opacity;
+        cairo_pattern_t *mask; // can be null
+        cairo_matrix_t mask_matrix;
+        Ref fontRef;
+    };
+    std::vector<SaveStateElement> saveStateStack;
+
+    std::map<Ref, std::map<std::string, std::unique_ptr<LinkDest>>> destsMap;
+    std::map<Ref, int> pdfPageRefToCairoPageNumMap;
+    std::vector<int> structParentsStack;
+    int currentStructParents;
+
+    struct StructParentsMcidHash
+    {
+        size_t operator()(std::pair<int, int> x) const { return x.first << 16 | x.second; }
+    };
+    std::unordered_set<std::pair<int, int>, StructParentsMcidHash> mcidEmitted; // <structParent, MCID>
+
+    std::unordered_set<const StructElement *> structElementNeeded;
+};
+
+//------------------------------------------------------------------------
+// CairoImageOutputDev
+//------------------------------------------------------------------------
+
+// XXX: this should ideally not inherit from CairoOutputDev but use it instead perhaps
+class CairoImageOutputDev : public CairoOutputDev
+{
+public:
+    // Constructor.
+    CairoImageOutputDev();
+
+    // Destructor.
+    ~CairoImageOutputDev() override;
+
+    //----- get info about output device
+
+    // Does this device use upside-down coordinates?
+    // (Upside-down means (0,0) is the top left corner of the page.)
+    bool upsideDown() override { return true; }
+
+    // Does this device use drawChar() or drawString()?
+    bool useDrawChar() override { return false; }
+
+    // Does this device use tilingPatternFill()?  If this returns false,
+    // tiling pattern fills will be reduced to a series of other drawing
+    // operations.
+    bool useTilingPatternFill() override { return true; }
+
+    // Does this device use functionShadedFill(), axialShadedFill(), and
+    // radialShadedFill()?  If this returns false, these shaded fills
+    // will be reduced to a series of other drawing operations.
+#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 11, 2)
+    bool useShadedFills(int type) override { return type <= 7; }
+#else
+    bool useShadedFills(int type) override { return type < 4; }
+#endif
+
+    // Does this device use FillColorStop()?
+    bool useFillColorStop() override { return false; }
+
+    // Does this device use beginType3Char/endType3Char?  Otherwise,
+    // text in Type 3 fonts will be drawn with drawChar/drawString.
+    bool interpretType3Chars() override { return false; }
+
+    // Does this device need non-text content?
+    bool needNonText() override { return true; }
+
+    //----- save/restore graphics state
+    void saveState(GfxState *state) override { }
+    void restoreState(GfxState *state) override { }
+
+    //----- update graphics state
+    void updateAll(GfxState *state) override { }
+    void setDefaultCTM(const double *ctm) override { }
+    void updateCTM(GfxState *state, double m11, double m12, double m21, double m22, double m31, double m32) override { }
+    void updateLineDash(GfxState *state) override { }
+    void updateFlatness(GfxState *state) override { }
+    void updateLineJoin(GfxState *state) override { }
+    void updateLineCap(GfxState *state) override { }
+    void updateMiterLimit(GfxState *state) override { }
+    void updateLineWidth(GfxState *state) override { }
+    void updateFillColor(GfxState *state) override { }
+    void updateStrokeColor(GfxState *state) override { }
+    void updateFillOpacity(GfxState *state) override { }
+    void updateStrokeOpacity(GfxState *state) override { }
+    void updateBlendMode(GfxState *state) override { }
+
+    //----- update text state
+    void updateFont(GfxState *state) override { }
+
+    //----- path painting
+    void stroke(GfxState *state) override { }
+    void fill(GfxState *state) override { }
+    void eoFill(GfxState *state) override { }
+    void clipToStrokePath(GfxState *state) override { }
+    bool tilingPatternFill(GfxState *state, Gfx *gfx, Catalog *cat, GfxTilingPattern *tPat, const double *mat, int x0, int y0, int x1, int y1, double xStep, double yStep) override { return true; }
+    bool axialShadedFill(GfxState *state, GfxAxialShading *shading, double tMin, double tMax) override { return true; }
+    bool radialShadedFill(GfxState *state, GfxRadialShading *shading, double sMin, double sMax) override { return true; }
+
+    //----- path clipping
+    void clip(GfxState *state) override { }
+    void eoClip(GfxState *state) override { }
+
+    //----- image drawing
+    void drawImageMask(GfxState *state, Object *ref, Stream *str, int width, int height, bool invert, bool interpolate, bool inlineImg) override;
+    void drawImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, bool interpolate, const int *maskColors, bool inlineImg) override;
+    void drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, bool interpolate, Stream *maskStr, int maskWidth, int maskHeight, GfxImageColorMap *maskColorMap,
+                             bool maskInterpolate) override;
+    void drawMaskedImage(GfxState *state, Object *ref, Stream *str, int width, int height, GfxImageColorMap *colorMap, bool interpolate, Stream *maskStr, int maskWidth, int maskHeight, bool maskInvert, bool maskInterpolate) override;
+    void setSoftMaskFromImageMask(GfxState *state, Object *ref, Stream *str, int width, int height, bool invert, bool inlineImg, double *baseMatrix) override;
+    void unsetSoftMaskFromImageMask(GfxState *state, double *baseMatrix) override { }
+
+    //----- transparency groups and soft masks
+    void beginTransparencyGroup(GfxState * /*state*/, const double * /*bbox*/, GfxColorSpace * /*blendingColorSpace*/, bool /*isolated*/, bool /*knockout*/, bool /*forSoftMask*/) override { }
+    void endTransparencyGroup(GfxState * /*state*/) override { }
+    void paintTransparencyGroup(GfxState * /*state*/, const double * /*bbox*/) override { }
+    void setSoftMask(GfxState * /*state*/, const double * /*bbox*/, bool /*alpha*/, Function * /*transferFunc*/, GfxColor * /*backdropColor*/) override { }
+    void clearSoftMask(GfxState * /*state*/) override { }
+
+    //----- Image list
+    // By default images are not rendred
+    void setImageDrawDecideCbk(bool (*cbk)(int img_id, void *data), void *data)
+    {
+        imgDrawCbk = cbk;
+        imgDrawCbkData = data;
+    }
+    // Iterate through list of images.
+    int getNumImages() const { return numImages; }
+    CairoImage *getImage(int i) const { return images[i]; }
+
+private:
+    void saveImage(CairoImage *image);
+    void getBBox(GfxState *state, int width, int height, double *x1, double *y1, double *x2, double *y2);
+
+    CairoImage **images;
+    int numImages;
+    int size;
+    bool (*imgDrawCbk)(int img_id, void *data);
+    void *imgDrawCbkData;
+};
+
+#endif

poppler-23.11.0/Library/include/poppler/CairoRescaleBox.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright © 2009 Mozilla Corporation
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that
+ * copyright notice and this permission notice appear in supporting
+ * documentation, and that the name of Mozilla Corporation not be used in
+ * advertising or publicity pertaining to distribution of the software without
+ * specific, written prior permission.  Mozilla Corporation makes no
+ * representations about the suitability of this software for any purpose.  It
+ * is provided "as is" without express or implied warranty.
+ *
+ * MOZILLA CORPORATION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT
+ * SHALL MOZILLA CORPORATION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ *
+ * Author: Jeff Muizelaar, Mozilla Corp.
+ */
+
+//========================================================================
+//
+// Modified under the Poppler project - http://poppler.freedesktop.org
+//
+// All changes made under the Poppler project to this file are licensed
+// under GPL version 2 or later
+//
+// Copyright (C) 2012 Adrian Johnson <[email protected]>
+// Copyright (C) 2018 Albert Astals Cid <[email protected]>
+//
+// To see a description of the changes please see the Changelog file that
+// came with your tarball or type make ChangeLog if you are building from git
+//
+//========================================================================
+
+#ifndef CAIRO_RESCALE_BOX_H
+#define CAIRO_RESCALE_BOX_H
+
+#include <cairo.h>
+
+class CairoRescaleBox
+{
+public:
+    CairoRescaleBox() {};
+    virtual ~CairoRescaleBox() {};
+
+    CairoRescaleBox(const CairoRescaleBox &) = delete;
+    CairoRescaleBox &operator=(const CairoRescaleBox &) = delete;
+
+    virtual bool downScaleImage(unsigned orig_width, unsigned orig_height, signed scaled_width, signed scaled_height, unsigned short int start_column, unsigned short int start_row, unsigned short int width, unsigned short int height,
+                                cairo_surface_t *dest_surface);
+
+    virtual void getRow(int row_num, uint32_t *row_data) = 0;
+};
+
+#endif /* CAIRO_RESCALE_BOX_H */

poppler-23.11.0/Library/include/poppler/Catalog.h

@@ -0,0 +1,321 @@
+//========================================================================
+//
+// Catalog.h
+//
+// Copyright 1996-2007 Glyph & Cog, LLC
+//
+//========================================================================
+
+//========================================================================
+//
+// Modified under the Poppler project - http://poppler.freedesktop.org
+//
+// All changes made under the Poppler project to this file are licensed
+// under GPL version 2 or later
+//
+// Copyright (C) 2005 Kristian Høgsberg <[email protected]>
+// Copyright (C) 2005, 2007, 2009-2011, 2013, 2017-2023 Albert Astals Cid <[email protected]>
+// Copyright (C) 2005 Jonathan Blandford <[email protected]>
+// Copyright (C) 2005, 2006, 2008 Brad Hards <[email protected]>
+// Copyright (C) 2007 Julien Rebetez <[email protected]>
+// Copyright (C) 2008, 2011 Pino Toscano <[email protected]>
+// Copyright (C) 2010 Hib Eris <[email protected]>
+// Copyright (C) 2012 Fabio D'Urso <[email protected]>
+// Copyright (C) 2013 Thomas Freitag <[email protected]>
+// Copyright (C) 2013 Adrian Perez de Castro <[email protected]>
+// Copyright (C) 2013, 2017 Adrian Johnson <[email protected]>
+// Copyright (C) 2013 José Aliste <[email protected]>
+// Copyright (C) 2016 Masamichi Hosoda <[email protected]>
+// Copyright (C) 2018 Klarälvdalens Datakonsult AB, a KDAB Group company, <[email protected]>. Work sponsored by the LiMux project of the city of Munich
+// Copyright (C) 2018 Adam Reichold <[email protected]>
+// Copyright (C) 2020 Oliver Sander <[email protected]>
+// Copyright (C) 2020 Katarina Behrens <[email protected]>
+// Copyright (C) 2020 Klarälvdalens Datakonsult AB, a KDAB Group company, <[email protected]>. Work sponsored by Technische Universität Dresden
+// Copyright (C) 2021 RM <[email protected]>
+//
+// To see a description of the changes please see the Changelog file that
+// came with your tarball or type make ChangeLog if you are building from git
+//
+//========================================================================
+
+#ifndef CATALOG_H
+#define CATALOG_H
+
+#include "poppler-config.h"
+#include "poppler_private_export.h"
+#include "Object.h"
+#include "Link.h"
+
+#include <memory>
+#include <optional>
+#include <vector>
+
+class PDFDoc;
+class XRef;
+class Object;
+class Page;
+class PageAttrs;
+struct Ref;
+class PageLabelInfo;
+class Form;
+class OCGs;
+class ViewerPreferences;
+class FileSpec;
+class StructTreeRoot;
+
+//------------------------------------------------------------------------
+// NameTree
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT NameTree
+{
+public:
+    NameTree();
+    ~NameTree();
+
+    NameTree(const NameTree &) = delete;
+    NameTree &operator=(const NameTree &) = delete;
+
+    void init(XRef *xref, Object *tree);
+    Object lookup(const GooString *name);
+    int numEntries() { return length; };
+    // iterator accessor, note it returns a pointer to the internal object, do not free nor delete it
+    Object *getValue(int i);
+    const GooString *getName(int i) const;
+
+private:
+    struct Entry
+    {
+        Entry(Array *array, int index);
+        ~Entry();
+        GooString name;
+        Object value;
+        static int cmpEntry(const void *voidEntry, const void *voidOtherEntry);
+        static int cmp(const void *key, const void *entry);
+    };
+
+    void parse(const Object *tree, RefRecursionChecker &seen);
+    void addEntry(Entry *entry);
+
+    XRef *xref;
+    Entry **entries;
+    int size, length; // size is the number of entries in
+                      // the array of Entry*
+                      // length is the number of real Entry
+};
+
+//------------------------------------------------------------------------
+// Catalog
+//------------------------------------------------------------------------
+
+class POPPLER_PRIVATE_EXPORT Catalog
+{
+public:
+    // Constructor.
+    explicit Catalog(PDFDoc *docA);
+
+    // Destructor.
+    ~Catalog();
+
+    Catalog(const Catalog &) = delete;
+    Catalog &operator=(const Catalog &) = delete;
+
+    // Is catalog valid?
+    bool isOk() { return ok; }
+
+    // Get number of pages.
+    int getNumPages();
+
+    // Get a page.
+    Page *getPage(int i);
+
+    // Get the reference for a page object.
+    Ref *getPageRef(int i);
+
+    // Return base URI, or NULL if none.
+    const std::optional<std::string> &getBaseURI() const { return baseURI; }
+
+    // Return the contents of the metadata stream, or NULL if there is
+    // no metadata.
+    std::unique_ptr<GooString> readMetadata();
+
+    // Return the structure tree root object.
+    StructTreeRoot *getStructTreeRoot();
+
+    // Return values from the MarkInfo dictionary as flags in a bitfield.
+    enum MarkInfoFlags
+    {
+        markInfoNull = 1 << 0,
+        markInfoMarked = 1 << 1,
+        markInfoUserProperties = 1 << 2,
+        markInfoSuspects = 1 << 3,
+    };
+    unsigned int getMarkInfo();
+
+    // Find a page, given its object ID.  Returns page number, or 0 if
+    // not found.
+    int findPage(const Ref pageRef);
+
+    // Find a named destination.  Returns the link destination, or
+    // NULL if <name> is not a destination.
+    std::unique_ptr<LinkDest> findDest(const GooString *name);
+
+    Object *getDests();
+
+    // Get the number of named destinations in name-dict
+    int numDests();
+
+    // Get the i'th named destination name in name-dict
+    const char *getDestsName(int i);
+
+    // Get the i'th named destination link destination in name-dict
+    std::unique_ptr<LinkDest> getDestsDest(int i);
+
+    // Get the number of named destinations in name-tree
+    int numDestNameTree() { return getDestNameTree()->numEntries(); }
+
+    // Get the i'th named destination name in name-tree
+    const GooString *getDestNameTreeName(int i) { return getDestNameTree()->getName(i); }
+
+    // Get the i'th named destination link destination in name-tree
+    std::unique_ptr<LinkDest> getDestNameTreeDest(int i);
+
+    // Get the number of embedded files
+    int numEmbeddedFiles() { return getEmbeddedFileNameTree()->numEntries(); }
+
+    // Get the i'th file embedded (at the Document level) in the document
+    std::unique_ptr<FileSpec> embeddedFile(int i);
+
+    // Is there an embedded file with the given name?
+    bool hasEmbeddedFile(const std::string &fileName);
+
+    // Adds and embeddedFile
+    // If there is already an existing embedded file with the given fileName
+    // it gets replaced, if that's not what you want check hasEmbeddedFile first
+    void addEmbeddedFile(GooFile *file, const std::string &fileName);
+
+    // Get the number of javascript scripts
+    int numJS() { return getJSNameTree()->numEntries(); }
+    const GooString *getJSName(int i) { return getJSNameTree()->getName(i); }
+
+    // Get the i'th JavaScript script (at the Document level) in the document
+    GooString *getJS(int i);
+
+    // Convert between page indices and page labels.
+    bool labelToIndex(GooString *label, int *index);
+    bool indexToLabel(int index, GooString *label);
+
+    Object *getOutline();
+    // returns the existing outline or new one if it doesn't exist
+    Object *getCreateOutline();
+
+    Object *getAcroForm() { return &acroForm; }
+    void addFormToAcroForm(const Ref formRef);
+    void removeFormFromAcroForm(const Ref formRef);
+    void setAcroFormModified();
+
+    OCGs *getOptContentConfig() { return optContent; }
+
+    int getPDFMajorVersion() const { return catalogPdfMajorVersion; }
+    int getPDFMinorVersion() const { return catalogPdfMinorVersion; }
+
+    enum FormType
+    {
+        NoForm,
+        AcroForm,
+        XfaForm
+    };
+
+    FormType getFormType();
+    // This can return nullptr if the document is in a very damaged state
+    Form *getCreateForm();
+    Form *getForm();
+
+    ViewerPreferences *getViewerPreferences();
+
+    enum PageMode
+    {
+        pageModeNone,
+        pageModeOutlines,
+        pageModeThumbs,
+        pageModeFullScreen,
+        pageModeOC,
+        pageModeAttach,
+        pageModeNull
+    };
+    enum PageLayout
+    {
+        pageLayoutNone,
+        pageLayoutSinglePage,
+        pageLayoutOneColumn,
+        pageLayoutTwoColumnLeft,
+        pageLayoutTwoColumnRight,
+        pageLayoutTwoPageLeft,
+        pageLayoutTwoPageRight,
+        pageLayoutNull
+    };
+
+    // Returns the page mode.
+    PageMode getPageMode();
+    PageLayout getPageLayout();
+
+    enum DocumentAdditionalActionsType
+    {
+        actionCloseDocument, ///< Performed before closing the document
+        actionSaveDocumentStart, ///< Performed before saving the document
+        actionSaveDocumentFinish, ///< Performed after saving the document
+        actionPrintDocumentStart, ///< Performed before printing the document
+        actionPrintDocumentFinish, ///< Performed after printing the document
+    };
+
+    std::unique_ptr<LinkAction> getAdditionalAction(DocumentAdditionalActionsType type);
+
+private:
+    // Get page label info.
+    PageLabelInfo *getPageLabelInfo();
+
+    PDFDoc *doc;
+    XRef *xref; // the xref table for this PDF file
+    std::vector<std::pair<std::unique_ptr<Page>, Ref>> pages;
+    std::vector<Object> *pagesList;
+    std::vector<Ref> *pagesRefList;
+    std::vector<PageAttrs *> *attrsList;
+    std::vector<int> *kidsIdxList;
+    Form *form;
+    ViewerPreferences *viewerPrefs;
+    int numPages; // number of pages
+    Object dests; // named destination dictionary
+    Object names; // named names dictionary
+    NameTree *destNameTree; // named destination name-tree
+    NameTree *embeddedFileNameTree; // embedded file name-tree
+    NameTree *jsNameTree; // Java Script name-tree
+    std::optional<std::string> baseURI; // base URI for URI-type links
+    Object metadata; // metadata stream
+    StructTreeRoot *structTreeRoot; // structure tree root
+    unsigned int markInfo; // Flags from MarkInfo dictionary
+    Object outline; // outline dictionary
+    Object acroForm; // AcroForm dictionary
+    Object viewerPreferences; // ViewerPreference dictionary
+    OCGs *optContent; // Optional Content groups
+    bool ok; // true if catalog is valid
+    PageLabelInfo *pageLabelInfo; // info about page labels
+    PageMode pageMode; // page mode
+    PageLayout pageLayout; // page layout
+    Object additionalActions; // page additional actions
+
+    bool cachePageTree(int page); // Cache first <page> pages.
+    Object *findDestInTree(Object *tree, GooString *name, Object *obj);
+
+    Object *getNames();
+    NameTree *getDestNameTree();
+    NameTree *getEmbeddedFileNameTree();
+    NameTree *getJSNameTree();
+    std::unique_ptr<LinkDest> createLinkDest(Object *obj);
+
+    int catalogPdfMajorVersion = -1;
+    int catalogPdfMinorVersion = -1;
+
+    mutable std::recursive_mutex mutex;
+};
+
+#endif