node-poppler 5.1.1 → 5.1.4

package/src/lib/win32/{poppler-21.11.0 → poppler-22.04.0}/Library/include/poppler/GfxFont.h

@@ -13,7 +13,7 @@
 // All changes made under the Poppler project to this file are licensed
 // under GPL version 2 or later
 //
-// Copyright (C) 2005, 2008, 2015, 2017-2021 Albert Astals Cid <aacid@kde.org>
+// Copyright (C) 2005, 2008, 2015, 2017-2022 Albert Astals Cid <aacid@kde.org>
 // Copyright (C) 2006 Takashi Iwai <tiwai@suse.de>
 // Copyright (C) 2006 Kristian Høgsberg <krh@redhat.com>
 // Copyright (C) 2007 Julien Rebetez <julienr@svn.gnome.org>
@@ -24,7 +24,7 @@
 // Copyright (C) 2015, 2018 Jason Crain <jason@aquaticape.us>
 // Copyright (C) 2015 Thomas Freitag <Thomas.Freitag@alfa.de>
 // Copyright (C) 2018 Klarälvdalens Datakonsult AB, a KDAB Group company, <info@kdab.com>. Work sponsored by the LiMux project of the city of Munich
-// Copyright (C) 2021 Oliver Sander <oliver.sander@tu-dresden.de>
+// Copyright (C) 2021, 2022 Oliver Sander <oliver.sander@tu-dresden.de>
 //
 // 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
@@ -34,6 +34,9 @@
 #ifndef GFXFONT_H
 #define GFXFONT_H
 
+#include <memory>
+#include <optional>
+
 #include "goo/GooString.h"
 #include "Object.h"
 #include "CharTypes.h"
@@ -119,16 +122,23 @@ public:
     ~GfxFontLoc();
 
     GfxFontLoc(const GfxFontLoc &) = delete;
+    GfxFontLoc(GfxFontLoc &&) noexcept;
     GfxFontLoc &operator=(const GfxFontLoc &) = delete;
+    GfxFontLoc &operator=(GfxFontLoc &&other) noexcept;
+
+    // Set the 'path' string from a GooString on the heap.
+    // Ownership of the object is taken.
+    void setPath(GooString *pathA);
+    const GooString *pathAsGooString() const;
 
     GfxFontLocType locType;
     GfxFontType fontType;
     Ref embFontID; // embedded stream obj ID
                    //   (if locType == gfxFontLocEmbedded)
-    GooString *path; // font file path
-                     //   (if locType == gfxFontLocExternal)
-                     // PS font name
-                     //   (if locType == gfxFontLocResident)
+    std::string path; // font file path
+                      //   (if locType == gfxFontLocExternal)
+                      // PS font name
+                      //   (if locType == gfxFontLocResident)
     int fontNum; // for TrueType collections
                  //   (if locType == gfxFontLocExternal)
     int substIdx; // substitute font index
@@ -178,16 +188,14 @@ public:
     };
 
     // Build a GfxFont object.
-    static GfxFont *makeFont(XRef *xref, const char *tagA, Ref idA, Dict *fontDict);
+    static std::unique_ptr<GfxFont> makeFont(XRef *xref, const char *tagA, Ref idA, Dict *fontDict);
 
     GfxFont(const GfxFont &) = delete;
     GfxFont &operator=(const GfxFont &other) = delete;
+    virtual ~GfxFont();
 
     bool isOk() const { return ok; }
 
-    void incRefCnt();
-    void decRefCnt();
-
     // Get font tag.
     const std::string &getTag() const { return tag; }
 
@@ -208,7 +216,7 @@ public:
 
     // Get the original font name (ignornig any munging that might have
     // been done to map to a canonical Base-14 font name).
-    const GooString *getName() const { return name; }
+    const std::optional<std::string> &getName() const { return name; }
 
     bool isSubset() const;
 
@@ -264,17 +272,14 @@ public:
     double getDescent() const { return descent; }
 
     // Return the writing mode (0=horizontal, 1=vertical).
-    virtual int getWMode() { return 0; }
+    virtual int getWMode() const { return 0; }
 
     // Locate the font file for this font.  If <ps> is not null, includes PS
-    // printer-resident fonts.  Returns NULL on failure.
-    GfxFontLoc *locateFont(XRef *xref, PSOutputDev *ps);
-
-    // Locate a Base-14 font file for a specified font name.
-    static GfxFontLoc *locateBase14Font(const GooString *base14Name);
+    // printer-resident fonts.  Returns std::optional without a value on failure.
+    std::optional<GfxFontLoc> locateFont(XRef *xref, PSOutputDev *ps);
 
     // Read an external or embedded font file into a buffer.
-    char *readEmbFontFile(XRef *xref, int *len);
+    std::optional<std::vector<unsigned char>> readEmbFontFile(XRef *xref);
 
     // Get the next char from a string <s> of <len> bytes, returning the
     // char <code>, its Unicode mapping <u>, its displacement vector
@@ -296,18 +301,16 @@ public:
     static const char *getAlternateName(const char *name);
 
 protected:
-    GfxFont(const char *tagA, Ref idA, const GooString *nameA, GfxFontType typeA, Ref embFontIDA);
-
-    virtual ~GfxFont();
+    GfxFont(const char *tagA, Ref idA, std::optional<std::string> &&nameA, GfxFontType typeA, Ref embFontIDA);
 
     static GfxFontType getFontType(XRef *xref, Dict *fontDict, Ref *embID);
     void readFontDescriptor(XRef *xref, Dict *fontDict);
     CharCodeToUnicode *readToUnicodeCMap(Dict *fontDict, int nBits, CharCodeToUnicode *ctu);
-    static GfxFontLoc *getExternalFont(GooString *path, bool cid);
+    static std::optional<GfxFontLoc> getExternalFont(GooString *path, bool cid);
 
     const std::string tag; // PDF font tag
     const Ref id; // reference (used as unique ID)
-    const GooString *name; // font name
+    std::optional<std::string> name; // font name
     GooString *family; // font family
     Stretch stretch; // font stretch
     Weight weight; // font weight
@@ -320,7 +323,6 @@ protected:
     double missingWidth; // "default" width
     double ascent; // max height above baseline
     double descent; // max depth below baseline
-    int refCnt;
     bool ok;
     bool hasToUnicode;
     std::string encodingName;
@@ -333,7 +335,7 @@ protected:
 class POPPLER_PRIVATE_EXPORT Gfx8BitFont : public GfxFont
 {
 public:
-    Gfx8BitFont(XRef *xref, const char *tagA, Ref idA, GooString *nameA, GfxFontType typeA, Ref embFontIDA, Dict *fontDict);
+    Gfx8BitFont(XRef *xref, const char *tagA, Ref idA, std::optional<std::string> &&nameA, GfxFontType typeA, Ref embFontIDA, Dict *fontDict);
 
     int getNextChar(const char *s, int len, CharCode *code, Unicode const **u, int *uLen, double *dx, double *dy, double *ox, double *oy) const override;
 
@@ -393,14 +395,14 @@ private:
 class POPPLER_PRIVATE_EXPORT GfxCIDFont : public GfxFont
 {
 public:
-    GfxCIDFont(XRef *xref, const char *tagA, Ref idA, GooString *nameA, GfxFontType typeA, Ref embFontIDA, Dict *fontDict);
+    GfxCIDFont(XRef *xref, const char *tagA, Ref idA, std::optional<std::string> &&nameA, GfxFontType typeA, Ref embFontIDA, Dict *fontDict);
 
     bool isCIDFont() const override { return true; }
 
     int getNextChar(const char *s, int len, CharCode *code, Unicode const **u, int *uLen, double *dx, double *dy, double *ox, double *oy) const override;
 
     // Return the writing mode (0=horizontal, 1=vertical).
-    int getWMode() override;
+    int getWMode() const override;
 
     // Return the Unicode map.
     const CharCodeToUnicode *getToUnicode() const override;
@@ -411,7 +413,7 @@ public:
     // Return the CID-to-GID mapping table.  These should only be called
     // if type is fontCIDType2.
     int *getCIDToGID() const { return cidToGID; }
-    int getCIDToGIDLen() const { return cidToGIDLen; }
+    unsigned int getCIDToGIDLen() const { return cidToGIDLen; }
 
     int *getCodeToGIDMap(FoFiTrueType *ff, int *codeToGIDLen);
 
@@ -424,14 +426,14 @@ private:
     double getWidth(CID cid) const; // Get width of a character.
 
     GooString *collection; // collection name
-    CMap *cMap; // char code --> CID
+    std::shared_ptr<CMap> cMap; // char code --> CID
     CharCodeToUnicode *ctu; // CID --> Unicode
     bool ctuUsesCharCode; // true: ctu maps char code to Unicode;
                           //   false: ctu maps CID to Unicode
     GfxFontCIDWidths widths; // character widths
     int *cidToGID; // CID --> GID mapping (for embedded
                    //   TrueType fonts)
-    int cidToGIDLen;
+    unsigned int cidToGIDLen;
 };
 
 //------------------------------------------------------------------------
@@ -444,25 +446,21 @@ public:
     // Build the font dictionary, given the PDF font dictionary.
     GfxFontDict(XRef *xref, Ref *fontDictRef, Dict *fontDict);
 
-    // Destructor.
-    ~GfxFontDict();
-
     GfxFontDict(const GfxFontDict &) = delete;
     GfxFontDict &operator=(const GfxFontDict &) = delete;
 
     // Get the specified font.
-    GfxFont *lookup(const char *tag) const;
+    std::shared_ptr<GfxFont> lookup(const char *tag) const;
 
     // Iterative access.
-    int getNumFonts() const { return numFonts; }
-    GfxFont *getFont(int i) const { return fonts[i]; }
+    int getNumFonts() const { return fonts.size(); }
+    const std::shared_ptr<GfxFont> &getFont(int i) const { return fonts[i]; }
 
 private:
     int hashFontObject(Object *obj);
     void hashFontObject1(const Object *obj, FNVHash *h);
 
-    GfxFont **fonts; // list of fonts
-    int numFonts; // number of fonts
+    std::vector<std::shared_ptr<GfxFont>> fonts;
 };
 
 #endif

package/src/lib/win32/{poppler-21.11.0 → poppler-22.04.0}/Library/include/poppler/GfxState.h

@@ -23,7 +23,7 @@
 // Copyright (C) 2011-2014, 2016, 2020 Thomas Freitag <Thomas.Freitag@alfa.de>
 // Copyright (C) 2013 Lu Wang <coolwanglu@gmail.com>
 // Copyright (C) 2015, 2017, 2020 Adrian Johnson <ajohnson@redneon.com>
-// Copyright (C) 2017, 2019 Oliver Sander <oliver.sander@tu-dresden.de>
+// Copyright (C) 2017, 2019, 2022 Oliver Sander <oliver.sander@tu-dresden.de>
 // Copyright (C) 2018 Adam Reichold <adam.reichold@t-online.de>
 // Copyright (C) 2020, 2021 Philipp Knechtges <philipp-dev@knechtges.com>
 //
@@ -1504,7 +1504,7 @@ public:
     bool getStrokeAdjust() const { return strokeAdjust; }
     bool getAlphaIsShape() const { return alphaIsShape; }
     bool getTextKnockout() const { return textKnockout; }
-    GfxFont *getFont() const { return font; }
+    const std::shared_ptr<GfxFont> &getFont() const { return font; }
     double getFontSize() const { return fontSize; }
     const double *getTextMat() const { return textMat; }
     double getCharSpace() const { return charSpace; }
@@ -1585,7 +1585,7 @@ public:
     void setStrokeAdjust(bool sa) { strokeAdjust = sa; }
     void setAlphaIsShape(bool ais) { alphaIsShape = ais; }
     void setTextKnockout(bool tk) { textKnockout = tk; }
-    void setFont(GfxFont *fontA, double fontSizeA);
+    void setFont(std::shared_ptr<GfxFont> fontA, double fontSizeA);
     void setTextMat(double a, double b, double c, double d, double e, double f)
     {
         textMat[0] = a;
@@ -1720,7 +1720,7 @@ private:
     bool alphaIsShape; // alpha is shape
     bool textKnockout; // text knockout
 
-    GfxFont *font; // font
+    std::shared_ptr<GfxFont> font; // font
     double fontSize; // font size
     double textMat[6]; // text matrix
     double charSpace; // character spacing

package/src/lib/win32/{poppler-21.11.0 → poppler-22.04.0}/Library/include/poppler/GlobalParams.h

@@ -13,7 +13,7 @@
 // All changes made under the Poppler project to this file are licensed
 // under GPL version 2 or later
 //
-// Copyright (C) 2005, 2007-2010, 2012, 2015, 2017-2021 Albert Astals Cid <aacid@kde.org>
+// Copyright (C) 2005, 2007-2010, 2012, 2015, 2017-2022 Albert Astals Cid <aacid@kde.org>
 // Copyright (C) 2005 Jonathan Blandford <jrb@redhat.com>
 // Copyright (C) 2006 Takashi Iwai <tiwai@suse.de>
 // Copyright (C) 2006 Kristian Høgsberg <krh@redhat.com>
@@ -115,7 +115,7 @@ public:
     FILE *getUnicodeMapFile(const std::string &encodingName);
     FILE *findCMapFile(const GooString *collection, const GooString *cMapName);
     FILE *findToUnicodeFile(const GooString *name);
-    GooString *findFontFile(const GooString *fontName);
+    GooString *findFontFile(const std::string &fontName);
     GooString *findBase14FontFile(const GooString *base14Name, const GfxFont *font);
     GooString *findSystemFontFile(const GfxFont *font, SysFontType *type, int *fontNum, GooString *substituteFontName = nullptr, const GooString *base14Name = nullptr);
     std::string getTextEncodingName() const;
@@ -125,7 +125,7 @@ public:
 
     CharCodeToUnicode *getCIDToUnicode(const GooString *collection);
     const UnicodeMap *getUnicodeMap(const std::string &encodingName);
-    CMap *getCMap(const GooString *collection, const GooString *cMapName);
+    std::shared_ptr<CMap> getCMap(const GooString *collection, const GooString *cMapName);
     const UnicodeMap *getTextEncoding();
 
     const UnicodeMap *getUtf8Map();

package/src/lib/win32/{poppler-21.11.0 → poppler-22.04.0}/Library/include/poppler/Lexer.h

@@ -77,8 +77,9 @@ public:
     // Set position in file.
     void setPos(Goffset pos)
     {
-        if (curStr.isStream())
+        if (curStr.isStream()) {
             curStr.getStream()->setPos(pos);
+        }
     }
 
     // Returns true if <c> is a whitespace character.

package/src/lib/win32/{poppler-21.11.0 → poppler-22.04.0}/Library/include/poppler/Link.h

@@ -17,7 +17,7 @@
 // Copyright (C) 2008 Hugo Mercier <hmercier31@gmail.com>
 // Copyright (C) 2010, 2011 Carlos Garcia Campos <carlosgc@gnome.org>
 // Copyright (C) 2012 Tobias Koening <tobias.koenig@kdab.com>
-// Copyright (C) 2018-2021 Albert Astals Cid <aacid@kde.org>
+// Copyright (C) 2018-2022 Albert Astals Cid <aacid@kde.org>
 // Copyright (C) 2018 Klarälvdalens Datakonsult AB, a KDAB Group company, <info@kdab.com>. Work sponsored by the LiMux project of the city of Munich
 // Copyright (C) 2018 Intevation GmbH <intevation@intevation.de>
 // Copyright (C) 2019, 2020 Oliver Sander <oliver.sander@tu-dresden.de>
@@ -35,6 +35,7 @@
 #include "Object.h"
 #include "poppler_private_export.h"
 #include <memory>
+#include <optional>
 #include <set>
 
 class GooString;
@@ -86,13 +87,13 @@ public:
     static std::unique_ptr<LinkAction> parseDest(const Object *obj);
 
     // Parse an action dictionary.
-    static std::unique_ptr<LinkAction> parseAction(const Object *obj, const GooString *baseURI = nullptr);
+    static std::unique_ptr<LinkAction> parseAction(const Object *obj, const std::optional<std::string> &baseURI = {});
 
     // A List of the next actions to execute in order.
     const std::vector<std::unique_ptr<LinkAction>> &nextActions() const;
 
 private:
-    static std::unique_ptr<LinkAction> parseAction(const Object *obj, const GooString *baseURI, std::set<int> *seenNextActions);
+    static std::unique_ptr<LinkAction> parseAction(const Object *obj, const std::optional<std::string> &baseURI, std::set<int> *seenNextActions);
 
     std::vector<std::unique_ptr<LinkAction>> nextActionList;
 };
@@ -119,9 +120,6 @@ public:
     // Build a LinkDest from the array.
     explicit LinkDest(const Array *a);
 
-    // Copy a LinkDest.
-    LinkDest *copy() const { return new LinkDest(this); }
-
     // Was the LinkDest created successfully?
     bool isOk() const { return ok; }
 
@@ -154,8 +152,6 @@ private:
                      //   destFitH/BH use changeTop;
                      //   destFitV/BV use changeLeft
     bool ok; // set if created successfully
-
-    explicit LinkDest(const LinkDest *dest);
 };
 
 //------------------------------------------------------------------------
@@ -247,7 +243,7 @@ class POPPLER_PRIVATE_EXPORT LinkURI : public LinkAction
 {
 public:
     // Build a LinkURI given the URI (string) and base URI.
-    LinkURI(const Object *uriObj, const GooString *baseURI);
+    LinkURI(const Object *uriObj, const std::optional<std::string> &baseURI);
 
     ~LinkURI() override;
 

package/src/lib/win32/{poppler-21.11.0 → poppler-22.04.0}/Library/include/poppler/LocalPDFDocBuilder.h

@@ -5,7 +5,7 @@
 // This file is licensed under the GPLv2 or later
 //
 // Copyright 2010 Hib Eris <hib@hiberis.nl>
-// Copyright 2010, 2018 Albert Astals Cid <aacid@kde.org>
+// Copyright 2010, 2018, 2022 Albert Astals Cid <aacid@kde.org>
 // Copyright 2021 Oliver Sander <oliver.sander@tu-dresden.de>
 //
 //========================================================================
@@ -25,7 +25,7 @@ class LocalPDFDocBuilder : public PDFDocBuilder
 {
 
 public:
-    std::unique_ptr<PDFDoc> buildPDFDoc(const GooString &uri, GooString *ownerPassword = nullptr, GooString *userPassword = nullptr, void *guiDataA = nullptr) override;
+    std::unique_ptr<PDFDoc> buildPDFDoc(const GooString &uri, const std::optional<GooString> &ownerPassword = {}, const std::optional<GooString> &userPassword = {}, void *guiDataA = nullptr) override;
     bool supports(const GooString &uri) override;
 };
 

package/src/lib/win32/{poppler-21.11.0 → poppler-22.04.0}/Library/include/poppler/MarkedContentOutputDev.h

@@ -7,6 +7,7 @@
 // Copyright 2013 Igalia S.L.
 // Copyright 2018-2021 Albert Astals Cid <aacid@kde.org>
 // Copyright 2021 Adrian Johnson <ajohnson@redneon.com>
+// Copyright 2022 Oliver Sander <oliver.sander@tu-dresden.de>
 //
 //========================================================================
 
@@ -39,28 +40,27 @@ public:
 
     ~TextSpan()
     {
-        if (data && --data->refcount == 0)
+        if (data && --data->refcount == 0) {
             delete data;
+        }
     }
 
-    GfxFont *getFont() const { return data->font; }
+    const std::shared_ptr<GfxFont> &getFont() const { return data->font; }
     GooString *getText() const { return data->text; }
     GfxRGB &getColor() const { return data->color; }
 
 private:
     // Note: Takes ownership of strings, increases refcount for font.
-    TextSpan(GooString *text, GfxFont *font, const GfxRGB color) : data(new Data)
+    TextSpan(GooString *text, std::shared_ptr<GfxFont> font, const GfxRGB color) : data(new Data)
     {
         data->text = text;
-        data->font = font;
+        data->font = std::move(font);
         data->color = color;
-        if (data->font)
-            data->font->incRefCnt();
     }
 
     struct Data
     {
-        GfxFont *font;
+        std::shared_ptr<GfxFont> font;
         GooString *text;
         GfxRGB color;
         unsigned refcount;
@@ -70,8 +70,6 @@ private:
         ~Data()
         {
             assert(refcount == 0);
-            if (font)
-                font->decRefCnt();
             delete text;
         }
 
@@ -116,9 +114,9 @@ private:
     void endSpan();
     bool inMarkedContent() const { return mcidStack.size() > 0; }
     bool contentStreamMatch();
-    bool needFontChange(const GfxFont *font) const;
+    bool needFontChange(const std::shared_ptr<const GfxFont> &font) const;
 
-    GfxFont *currentFont;
+    std::shared_ptr<GfxFont> currentFont;
     GooString *currentText;
     GfxRGB currentColor;
     TextSpanArray textSpans;

package/src/lib/win32/{poppler-21.11.0 → poppler-22.04.0}/Library/include/poppler/Movie.h

@@ -5,7 +5,7 @@
 //---------------------------------------------------------------------------------
 // Hugo Mercier <hmercier31[at]gmail.com> (c) 2008
 // Carlos Garcia Campos <carlosgc@gnome.org> (c) 2010
-// Albert Astals Cid <aacid@kde.org> (c) 2017-2019, 2021
+// Albert Astals Cid <aacid@kde.org> (c) 2017-2019, 2021, 2022
 //
 // This program is free software; you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -28,6 +28,8 @@
 #include "Object.h"
 #include "poppler_private_export.h"
 
+#include <memory>
+
 struct MovieActivationParameters
 {
 
@@ -99,7 +101,7 @@ public:
     bool getUseFloatingWindow() const { return MA.floatingWindow; }
     void getFloatingWindowSize(int *width, int *height);
 
-    Movie *copy() const;
+    std::unique_ptr<Movie> copy() const;
 
 private:
     void parseMovie(const Object *movieDict);

package/src/lib/win32/{poppler-21.11.0 → poppler-22.04.0}/Library/include/poppler/Object.h

@@ -107,8 +107,9 @@ inline bool operator!=(const Ref lhs, const Ref rhs) noexcept
 
 inline bool operator<(const Ref lhs, const Ref rhs) noexcept
 {
-    if (lhs.num != rhs.num)
+    if (lhs.num != rhs.num) {
         return lhs.num < rhs.num;
+    }
     return lhs.gen < rhs.gen;
 }
 
@@ -263,9 +264,14 @@ public:
         type = objNull;
     }
 
-    // Copy this to obj
+    // Copies all object types except
+    // objArray, objDict, objStream whose refcount is increased by 1
     Object copy() const;
 
+    // Deep copies all object types (recursively)
+    // except objStream whose refcount is increased by 1
+    Object deepCopy() const;
+
     // If object is a Ref, fetch and return the referenced object.
     // Otherwise, return a copy of the object.
     Object fetch(XRef *xref, int recursion = 0) const;
@@ -409,24 +415,11 @@ public:
         OBJECT_TYPE_CHECK(objString);
         return string;
     }
-    // After takeString() the only method that should be called for the object is free().
-    GooString *takeString()
-    {
-        OBJECT_TYPE_CHECK(objString);
-        type = objDead;
-        return string;
-    }
     const GooString *getHexString() const
     {
         OBJECT_TYPE_CHECK(objHexString);
         return string;
     }
-    GooString *takeHexString()
-    {
-        OBJECT_TYPE_CHECK(objHexString);
-        type = objDead;
-        return string;
-    }
     const char *getName() const
     {
         OBJECT_TYPE_CHECK(objName);

package/src/lib/win32/{poppler-21.11.0 → poppler-22.04.0}/Library/include/poppler/Outline.h

@@ -54,10 +54,11 @@ public:
 
     const std::vector<OutlineItem *> *getItems() const
     {
-        if (!items || items->empty())
+        if (!items || items->empty()) {
             return nullptr;
-        else
+        } else {
             return items;
+        }
     }
 
     struct OutlineTreeNode